namespace Knownet.BNF.Inline.Lang.CSharp
{
    using System;
    using Knownet.AST;
    using Knownet.BNF.Inline;

    public class CSharpDefinition:BnfDefinition
    {
        public class Eof:CSharpDefinition
        {
            public static Eof Instance
            {
                get
                {
                    return new Eof().DefineAs(
                        R("EOF")
                    ) as Eof;
                }
            }
        }

        public class None:CSharpDefinition
        {
            public static None Instance
            {
                get
                {
                    return new None().DefineAs(
                        R("NONE")
                    ) as None;
                }
            }
        }

        public class Error:CSharpDefinition
        {
            public static Error Instance
            {
                get
                {
                    return new Error().DefineAs(
                        R("ERROR")
                    ) as Error;
                }
            }
        }

        public class Abstract:CSharpDefinition
        {
            public static Abstract Instance
            {
                get
                {
                    return new Abstract().DefineAs(
                        T("abstract")
                    ) as Abstract;
                }
            }
        }

        public class As:CSharpDefinition
        {
            public static As Instance
            {
                get
                {
                    return new As().DefineAs(
                        T("as")
                    ) as As;
                }
            }
        }

        public class Add:CSharpDefinition
        {
            public static Add Instance
            {
                get
                {
                    return new Add().DefineAs(
                        T("add")
                    ) as Add;
                }
            }
        }

        public class Assembly:CSharpDefinition
        {
            public static Assembly Instance
            {
                get
                {
                    return new Assembly().DefineAs(
                        T("assembly")
                    ) as Assembly;
                }
            }
        }

        public class Base:CSharpDefinition
        {
            public static Base Instance
            {
                get
                {
                    return new Base().DefineAs(
                        T("base")
                    ) as Base;
                }
            }
        }

        public class Bool:CSharpDefinition
        {
            public static Bool Instance
            {
                get
                {
                    return new Bool().DefineAs(
                        T("bool")
                    ) as Bool;
                }
            }
        }

        public class Break:CSharpDefinition
        {
            public static Break Instance
            {
                get
                {
                    return new Break().DefineAs(
                        T("break")
                    ) as Break;
                }
            }
        }

        public class Byte:CSharpDefinition
        {
            public static Byte Instance
            {
                get
                {
                    return new Byte().DefineAs(
                        T("byte")
                    ) as Byte;
                }
            }
        }

        public class Case:CSharpDefinition
        {
            public static Case Instance
            {
                get
                {
                    return new Case().DefineAs(
                        T("case")
                    ) as Case;
                }
            }
        }

        public class Catch:CSharpDefinition
        {
            public static Catch Instance
            {
                get
                {
                    return new Catch().DefineAs(
                        T("catch")
                    ) as Catch;
                }
            }
        }

        public class Char:CSharpDefinition
        {
            public static Char Instance
            {
                get
                {
                    return new Char().DefineAs(
                        T("char")
                    ) as Char;
                }
            }
        }

        public class Checked:CSharpDefinition
        {
            public static Checked Instance
            {
                get
                {
                    return new Checked().DefineAs(
                        T("checked")
                    ) as Checked;
                }
            }
        }

        public class Class:CSharpDefinition
        {
            public static Class Instance
            {
                get
                {
                    return new Class().DefineAs(
                        T("class")
                    ) as Class;
                }
            }
        }

        public class Const:CSharpDefinition
        {
            public static Const Instance
            {
                get
                {
                    return new Const().DefineAs(
                        T("const")
                    ) as Const;
                }
            }
        }

        public class Continue:CSharpDefinition
        {
            public static Continue Instance
            {
                get
                {
                    return new Continue().DefineAs(
                        T("continue")
                    ) as Continue;
                }
            }
        }

        public class Decimal:CSharpDefinition
        {
            public static Decimal Instance
            {
                get
                {
                    return new Decimal().DefineAs(
                        T("decimal")
                    ) as Decimal;
                }
            }
        }

        public class Default:CSharpDefinition
        {
            public static Default Instance
            {
                get
                {
                    return new Default().DefineAs(
                        T("default")
                    ) as Default;
                }
            }
        }

        public class Delegate:CSharpDefinition
        {
            public static Delegate Instance
            {
                get
                {
                    return new Delegate().DefineAs(
                        T("delegate")
                    ) as Delegate;
                }
            }
        }

        public class Do:CSharpDefinition
        {
            public static Do Instance
            {
                get
                {
                    return new Do().DefineAs(
                        T("do")
                    ) as Do;
                }
            }
        }

        public class Double:CSharpDefinition
        {
            public static Double Instance
            {
                get
                {
                    return new Double().DefineAs(
                        T("double")
                    ) as Double;
                }
            }
        }

        public class Else:CSharpDefinition
        {
            public static Else Instance
            {
                get
                {
                    return new Else().DefineAs(
                        T("else")
                    ) as Else;
                }
            }
        }

        public class Enum:CSharpDefinition
        {
            public static Enum Instance
            {
                get
                {
                    return new Enum().DefineAs(
                        T("enum")
                    ) as Enum;
                }
            }
        }

        public class Event:CSharpDefinition
        {
            public static Event Instance
            {
                get
                {
                    return new Event().DefineAs(
                        T("event")
                    ) as Event;
                }
            }
        }

        public class Explicit:CSharpDefinition
        {
            public static Explicit Instance
            {
                get
                {
                    return new Explicit().DefineAs(
                        T("explicit")
                    ) as Explicit;
                }
            }
        }

        public class Extern:CSharpDefinition
        {
            public static Extern Instance
            {
                get
                {
                    return new Extern().DefineAs(
                        T("extern")
                    ) as Extern;
                }
            }
        }

        public class False:CSharpDefinition
        {
            public static False Instance
            {
                get
                {
                    return new False().DefineAs(
                        T("false")
                    ) as False;
                }
            }
        }

        public class Finally:CSharpDefinition
        {
            public static Finally Instance
            {
                get
                {
                    return new Finally().DefineAs(
                        T("finally")
                    ) as Finally;
                }
            }
        }

        public class Fixed:CSharpDefinition
        {
            public static Fixed Instance
            {
                get
                {
                    return new Fixed().DefineAs(
                        T("fixed")
                    ) as Fixed;
                }
            }
        }

        public class Float:CSharpDefinition
        {
            public static Float Instance
            {
                get
                {
                    return new Float().DefineAs(
                        T("float")
                    ) as Float;
                }
            }
        }

        public class For:CSharpDefinition
        {
            public static For Instance
            {
                get
                {
                    return new For().DefineAs(
                        T("for")
                    ) as For;
                }
            }
        }

        public class Foreach:CSharpDefinition
        {
            public static Foreach Instance
            {
                get
                {
                    return new Foreach().DefineAs(
                        T("foreach")
                    ) as Foreach;
                }
            }
        }

        public class Goto:CSharpDefinition
        {
            public static Goto Instance
            {
                get
                {
                    return new Goto().DefineAs(
                        T("goto")
                    ) as Goto;
                }
            }
        }

        public class If:CSharpDefinition
        {
            public static If Instance
            {
                get
                {
                    return new If().DefineAs(
                        T("if")
                    ) as If;
                }
            }
        }

        public class Implicit:CSharpDefinition
        {
            public static Implicit Instance
            {
                get
                {
                    return new Implicit().DefineAs(
                        T("implicit")
                    ) as Implicit;
                }
            }
        }

        public class In:CSharpDefinition
        {
            public static In Instance
            {
                get
                {
                    return new In().DefineAs(
                        T("in")
                    ) as In;
                }
            }
        }

        public class Int:CSharpDefinition
        {
            public static Int Instance
            {
                get
                {
                    return new Int().DefineAs(
                        T("int")
                    ) as Int;
                }
            }
        }

        public class Interface:CSharpDefinition
        {
            public static Interface Instance
            {
                get
                {
                    return new Interface().DefineAs(
                        T("interface")
                    ) as Interface;
                }
            }
        }

        public class Internal:CSharpDefinition
        {
            public static Internal Instance
            {
                get
                {
                    return new Internal().DefineAs(
                        T("internal")
                    ) as Internal;
                }
            }
        }

        public class Is:CSharpDefinition
        {
            public static Is Instance
            {
                get
                {
                    return new Is().DefineAs(
                        T("is")
                    ) as Is;
                }
            }
        }

        public class Lock:CSharpDefinition
        {
            public static Lock Instance
            {
                get
                {
                    return new Lock().DefineAs(
                        T("lock")
                    ) as Lock;
                }
            }
        }

        public class Long:CSharpDefinition
        {
            public static Long Instance
            {
                get
                {
                    return new Long().DefineAs(
                        T("long")
                    ) as Long;
                }
            }
        }

        public class Namespace:CSharpDefinition
        {
            public static Namespace Instance
            {
                get
                {
                    return new Namespace().DefineAs(
                        T("namespace")
                    ) as Namespace;
                }
            }
        }

        public class New:CSharpDefinition
        {
            public static New Instance
            {
                get
                {
                    return new New().DefineAs(
                        T("new")
                    ) as New;
                }
            }
        }

        public class Null:CSharpDefinition
        {
            public static Null Instance
            {
                get
                {
                    return new Null().DefineAs(
                        T("null")
                    ) as Null;
                }
            }
        }

        public class Object:CSharpDefinition
        {
            public static Object Instance
            {
                get
                {
                    return new Object().DefineAs(
                        T("object")
                    ) as Object;
                }
            }
        }

        public class Operator:CSharpDefinition
        {
            public static Operator Instance
            {
                get
                {
                    return new Operator().DefineAs(
                        T("operator")
                    ) as Operator;
                }
            }
        }

        public class Out:CSharpDefinition
        {
            public static Out Instance
            {
                get
                {
                    return new Out().DefineAs(
                        T("out")
                    ) as Out;
                }
            }
        }

        public class Override:CSharpDefinition
        {
            public static Override Instance
            {
                get
                {
                    return new Override().DefineAs(
                        T("override")
                    ) as Override;
                }
            }
        }

        public class Params:CSharpDefinition
        {
            public static Params Instance
            {
                get
                {
                    return new Params().DefineAs(
                        T("params")
                    ) as Params;
                }
            }
        }

        public class Private:CSharpDefinition
        {
            public static Private Instance
            {
                get
                {
                    return new Private().DefineAs(
                        T("private")
                    ) as Private;
                }
            }
        }

        public class Protected:CSharpDefinition
        {
            public static Protected Instance
            {
                get
                {
                    return new Protected().DefineAs(
                        T("protected")
                    ) as Protected;
                }
            }
        }

        public class Public:CSharpDefinition
        {
            public static Public Instance
            {
                get
                {
                    return new Public().DefineAs(
                        T("public")
                    ) as Public;
                }
            }
        }

        public class Readonly:CSharpDefinition
        {
            public static Readonly Instance
            {
                get
                {
                    return new Readonly().DefineAs(
                        T("readonly")
                    ) as Readonly;
                }
            }
        }

        public class Ref:CSharpDefinition
        {
            public static Ref Instance
            {
                get
                {
                    return new Ref().DefineAs(
                        T("ref")
                    ) as Ref;
                }
            }
        }

        public class Return:CSharpDefinition
        {
            public static Return Instance
            {
                get
                {
                    return new Return().DefineAs(
                        T("return")
                    ) as Return;
                }
            }
        }

        public class Remove:CSharpDefinition
        {
            public static Remove Instance
            {
                get
                {
                    return new Remove().DefineAs(
                        T("remove")
                    ) as Remove;
                }
            }
        }

        public class Sbyte:CSharpDefinition
        {
            public static Sbyte Instance
            {
                get
                {
                    return new Sbyte().DefineAs(
                        T("sbyte")
                    ) as Sbyte;
                }
            }
        }

        public class Sealed:CSharpDefinition
        {
            public static Sealed Instance
            {
                get
                {
                    return new Sealed().DefineAs(
                        T("sealed")
                    ) as Sealed;
                }
            }
        }

        public class Short:CSharpDefinition
        {
            public static Short Instance
            {
                get
                {
                    return new Short().DefineAs(
                        T("short")
                    ) as Short;
                }
            }
        }

        public class Sizeof:CSharpDefinition
        {
            public static Sizeof Instance
            {
                get
                {
                    return new Sizeof().DefineAs(
                        T("sizeof")
                    ) as Sizeof;
                }
            }
        }

        public class Stackalloc:CSharpDefinition
        {
            public static Stackalloc Instance
            {
                get
                {
                    return new Stackalloc().DefineAs(
                        T("stackalloc")
                    ) as Stackalloc;
                }
            }
        }

        public class Static:CSharpDefinition
        {
            public static Static Instance
            {
                get
                {
                    return new Static().DefineAs(
                        T("static")
                    ) as Static;
                }
            }
        }

        public class String:CSharpDefinition
        {
            public static String Instance
            {
                get
                {
                    return new String().DefineAs(
                        T("string")
                    ) as String;
                }
            }
        }

        public class Struct:CSharpDefinition
        {
            public static Struct Instance
            {
                get
                {
                    return new Struct().DefineAs(
                        T("struct")
                    ) as Struct;
                }
            }
        }

        public class Switch:CSharpDefinition
        {
            public static Switch Instance
            {
                get
                {
                    return new Switch().DefineAs(
                        T("switch")
                    ) as Switch;
                }
            }
        }

        public class This:CSharpDefinition
        {
            public static This Instance
            {
                get
                {
                    return new This().DefineAs(
                        T("this")
                    ) as This;
                }
            }
        }

        public class Throw:CSharpDefinition
        {
            public static Throw Instance
            {
                get
                {
                    return new Throw().DefineAs(
                        T("throw")
                    ) as Throw;
                }
            }
        }

        public class True:CSharpDefinition
        {
            public static True Instance
            {
                get
                {
                    return new True().DefineAs(
                        T("true")
                    ) as True;
                }
            }
        }

        public class Try:CSharpDefinition
        {
            public static Try Instance
            {
                get
                {
                    return new Try().DefineAs(
                        T("try")
                    ) as Try;
                }
            }
        }

        public class Typeof:CSharpDefinition
        {
            public static Typeof Instance
            {
                get
                {
                    return new Typeof().DefineAs(
                        T("typeof")
                    ) as Typeof;
                }
            }
        }

        public class Uint:CSharpDefinition
        {
            public static Uint Instance
            {
                get
                {
                    return new Uint().DefineAs(
                        T("uint")
                    ) as Uint;
                }
            }
        }

        public class Ulong:CSharpDefinition
        {
            public static Ulong Instance
            {
                get
                {
                    return new Ulong().DefineAs(
                        T("ulong")
                    ) as Ulong;
                }
            }
        }

        public class Unchecked:CSharpDefinition
        {
            public static Unchecked Instance
            {
                get
                {
                    return new Unchecked().DefineAs(
                        T("unchecked")
                    ) as Unchecked;
                }
            }
        }

        public class Unsafe:CSharpDefinition
        {
            public static Unsafe Instance
            {
                get
                {
                    return new Unsafe().DefineAs(
                        T("unsafe")
                    ) as Unsafe;
                }
            }
        }

        public class Ushort:CSharpDefinition
        {
            public static Ushort Instance
            {
                get
                {
                    return new Ushort().DefineAs(
                        T("ushort")
                    ) as Ushort;
                }
            }
        }

        public class Using:CSharpDefinition
        {
            public static Using Instance
            {
                get
                {
                    return new Using().DefineAs(
                        T("using")
                    ) as Using;
                }
            }
        }

        public class Virtual:CSharpDefinition
        {
            public static Virtual Instance
            {
                get
                {
                    return new Virtual().DefineAs(
                        T("virtual")
                    ) as Virtual;
                }
            }
        }

        public class Void:CSharpDefinition
        {
            public static Void Instance
            {
                get
                {
                    return new Void().DefineAs(
                        T("void")
                    ) as Void;
                }
            }
        }

        public class Volatile:CSharpDefinition
        {
            public static Volatile Instance
            {
                get
                {
                    return new Volatile().DefineAs(
                        T("volatile")
                    ) as Volatile;
                }
            }
        }

        public class While:CSharpDefinition
        {
            public static While Instance
            {
                get
                {
                    return new While().DefineAs(
                        T("while")
                    ) as While;
                }
            }
        }

        public class Get:CSharpDefinition
        {
            public static Get Instance
            {
                get
                {
                    return new Get().DefineAs(
                        T("get")
                    ) as Get;
                }
            }
        }

        public class Set:CSharpDefinition
        {
            public static Set Instance
            {
                get
                {
                    return new Set().DefineAs(
                        T("set")
                    ) as Set;
                }
            }
        }

        public class OpenBrace:CSharpDefinition
        {
            public static OpenBrace Instance
            {
                get
                {
                    return new OpenBrace().DefineAs(
                        T("{")
                    ) as OpenBrace;
                }
            }
        }

        public class CloseBrace:CSharpDefinition
        {
            public static CloseBrace Instance
            {
                get
                {
                    return new CloseBrace().DefineAs(
                        T("}")
                    ) as CloseBrace;
                }
            }
        }

        public class OpenBracket:CSharpDefinition
        {
            public static OpenBracket Instance
            {
                get
                {
                    return new OpenBracket().DefineAs(
                        T("[")
                    ) as OpenBracket;
                }
            }
        }

        public class CloseBracket:CSharpDefinition
        {
            public static CloseBracket Instance
            {
                get
                {
                    return new CloseBracket().DefineAs(
                        T("]")
                    ) as CloseBracket;
                }
            }
        }

        public class OpenParens:CSharpDefinition
        {
            public static OpenParens Instance
            {
                get
                {
                    return new OpenParens().DefineAs(
                        T("(")
                    ) as OpenParens;
                }
            }
        }

        public class CloseParens:CSharpDefinition
        {
            public static CloseParens Instance
            {
                get
                {
                    return new CloseParens().DefineAs(
                        T(")")
                    ) as CloseParens;
                }
            }
        }

        public class Dot:CSharpDefinition
        {
            public static Dot Instance
            {
                get
                {
                    return new Dot().DefineAs(
                        T(".")
                    ) as Dot;
                }
            }
        }

        public class Comma:CSharpDefinition
        {
            public static Comma Instance
            {
                get
                {
                    return new Comma().DefineAs(
                        T(",")
                    ) as Comma;
                }
            }
        }

        public class Colon:CSharpDefinition
        {
            public static Colon Instance
            {
                get
                {
                    return new Colon().DefineAs(
                        T(":")
                    ) as Colon;
                }
            }
        }

        public class Semicolon:CSharpDefinition
        {
            public static Semicolon Instance
            {
                get
                {
                    return new Semicolon().DefineAs(
                        T(";")
                    ) as Semicolon;
                }
            }
        }

        public class Tilde:CSharpDefinition
        {
            public static Tilde Instance
            {
                get
                {
                    return new Tilde().DefineAs(
                        T("~")
                    ) as Tilde;
                }
            }
        }

        public class Plus:CSharpDefinition
        {
            public static Plus Instance
            {
                get
                {
                    return new Plus().DefineAs(
                        T("+")
                    ) as Plus;
                }
            }
        }

        public class Minus:CSharpDefinition
        {
            public static Minus Instance
            {
                get
                {
                    return new Minus().DefineAs(
                        T("-")
                    ) as Minus;
                }
            }
        }

        public class Bang:CSharpDefinition
        {
            public static Bang Instance
            {
                get
                {
                    return new Bang().DefineAs(
                        T("!")
                    ) as Bang;
                }
            }
        }

        public class Assign:CSharpDefinition
        {
            public static Assign Instance
            {
                get
                {
                    return new Assign().DefineAs(
                        T("=")
                    ) as Assign;
                }
            }
        }

        public class OpLt:CSharpDefinition
        {
            public static OpLt Instance
            {
                get
                {
                    return new OpLt().DefineAs(
                        T("<")
                    ) as OpLt;
                }
            }
        }

        public class OpGt:CSharpDefinition
        {
            public static OpGt Instance
            {
                get
                {
                    return new OpGt().DefineAs(
                        T(">")
                    ) as OpGt;
                }
            }
        }

        public class BitwiseAnd:CSharpDefinition
        {
            public static BitwiseAnd Instance
            {
                get
                {
                    return new BitwiseAnd().DefineAs(
                        T("&")
                    ) as BitwiseAnd;
                }
            }
        }

        public class BitwiseOr:CSharpDefinition
        {
            public static BitwiseOr Instance
            {
                get
                {
                    return new BitwiseOr().DefineAs(
                        T("|")
                    ) as BitwiseOr;
                }
            }
        }

        public class Star:CSharpDefinition
        {
            public static Star Instance
            {
                get
                {
                    return new Star().DefineAs(
                        T("*")
                    ) as Star;
                }
            }
        }

        public class Percent:CSharpDefinition
        {
            public static Percent Instance
            {
                get
                {
                    return new Percent().DefineAs(
                        T("%")
                    ) as Percent;
                }
            }
        }

        public class Div:CSharpDefinition
        {
            public static Div Instance
            {
                get
                {
                    return new Div().DefineAs(
                        T("/")
                    ) as Div;
                }
            }
        }

        public class Carret:CSharpDefinition
        {
            public static Carret Instance
            {
                get
                {
                    return new Carret().DefineAs(
                        T("^")
                    ) as Carret;
                }
            }
        }

        public class Interr:CSharpDefinition
        {
            public static Interr Instance
            {
                get
                {
                    return new Interr().DefineAs(
                        T("?")
                    ) as Interr;
                }
            }
        }

        public class OpInc:CSharpDefinition
        {
            public static OpInc Instance
            {
                get
                {
                    return new OpInc().DefineAs(
                        T("++")
                    ) as OpInc;
                }
            }
        }

        public class OpDec:CSharpDefinition
        {
            public static OpDec Instance
            {
                get
                {
                    return new OpDec().DefineAs(
                        T("--")
                    ) as OpDec;
                }
            }
        }

        public class OpShiftLeft:CSharpDefinition
        {
            public static OpShiftLeft Instance
            {
                get
                {
                    return new OpShiftLeft().DefineAs(
                        T("<<")
                    ) as OpShiftLeft;
                }
            }
        }

        public class OpShiftRight:CSharpDefinition
        {
            public static OpShiftRight Instance
            {
                get
                {
                    return new OpShiftRight().DefineAs(
                        T(">>")
                    ) as OpShiftRight;
                }
            }
        }

        public class OpLe:CSharpDefinition
        {
            public static OpLe Instance
            {
                get
                {
                    return new OpLe().DefineAs(
                        T("<=")
                    ) as OpLe;
                }
            }
        }

        public class OpGe:CSharpDefinition
        {
            public static OpGe Instance
            {
                get
                {
                    return new OpGe().DefineAs(
                        T(">=")
                    ) as OpGe;
                }
            }
        }

        public class OpEq:CSharpDefinition
        {
            public static OpEq Instance
            {
                get
                {
                    return new OpEq().DefineAs(
                        T("==")
                    ) as OpEq;
                }
            }
        }

        public class OpNe:CSharpDefinition
        {
            public static OpNe Instance
            {
                get
                {
                    return new OpNe().DefineAs(
                        T("!=")
                    ) as OpNe;
                }
            }
        }

        public class OpAnd:CSharpDefinition
        {
            public static OpAnd Instance
            {
                get
                {
                    return new OpAnd().DefineAs(
                        T("&&")
                    ) as OpAnd;
                }
            }
        }

        public class OpOr:CSharpDefinition
        {
            public static OpOr Instance
            {
                get
                {
                    return new OpOr().DefineAs(
                        T("||")
                    ) as OpOr;
                }
            }
        }

        public class OpMultAssign:CSharpDefinition
        {
            public static OpMultAssign Instance
            {
                get
                {
                    return new OpMultAssign().DefineAs(
                        T("*=")
                    ) as OpMultAssign;
                }
            }
        }

        public class OpDivAssign:CSharpDefinition
        {
            public static OpDivAssign Instance
            {
                get
                {
                    return new OpDivAssign().DefineAs(
                        T("/=")
                    ) as OpDivAssign;
                }
            }
        }

        public class OpModAssign:CSharpDefinition
        {
            public static OpModAssign Instance
            {
                get
                {
                    return new OpModAssign().DefineAs(
                        T("%=")
                    ) as OpModAssign;
                }
            }
        }

        public class OpAddAssign:CSharpDefinition
        {
            public static OpAddAssign Instance
            {
                get
                {
                    return new OpAddAssign().DefineAs(
                        T("+=")
                    ) as OpAddAssign;
                }
            }
        }

        public class OpSubAssign:CSharpDefinition
        {
            public static OpSubAssign Instance
            {
                get
                {
                    return new OpSubAssign().DefineAs(
                        T("-=")
                    ) as OpSubAssign;
                }
            }
        }

        public class OpShiftLeftAssign:CSharpDefinition
        {
            public static OpShiftLeftAssign Instance
            {
                get
                {
                    return new OpShiftLeftAssign().DefineAs(
                        T("<<=")
                    ) as OpShiftLeftAssign;
                }
            }
        }

        public class OpShiftRightAssign:CSharpDefinition
        {
            public static OpShiftRightAssign Instance
            {
                get
                {
                    return new OpShiftRightAssign().DefineAs(
                        T(">>=")
                    ) as OpShiftRightAssign;
                }
            }
        }

        public class OpAndAssign:CSharpDefinition
        {
            public static OpAndAssign Instance
            {
                get
                {
                    return new OpAndAssign().DefineAs(
                        T("&=")
                    ) as OpAndAssign;
                }
            }
        }

        public class OpXorAssign:CSharpDefinition
        {
            public static OpXorAssign Instance
            {
                get
                {
                    return new OpXorAssign().DefineAs(
                        T("^=")
                    ) as OpXorAssign;
                }
            }
        }

        public class OpOrAssign:CSharpDefinition
        {
            public static OpOrAssign Instance
            {
                get
                {
                    return new OpOrAssign().DefineAs(
                        T("|=")
                    ) as OpOrAssign;
                }
            }
        }

        public class OpPtr:CSharpDefinition
        {
            public static OpPtr Instance
            {
                get
                {
                    return new OpPtr().DefineAs(
                        T("->")
                    ) as OpPtr;
                }
            }
        }

        public class LiteralInteger:CSharpDefinition
        {
            public static LiteralInteger Instance
            {
                get
                {
                    return new LiteralInteger().DefineAs(
                        R("int_literal")
                    ) as LiteralInteger;
                }
            }
        }

        public class LiteralFloat:CSharpDefinition
        {
            public static LiteralFloat Instance
            {
                get
                {
                    return new LiteralFloat().DefineAs(
                        R("float_literal")
                    ) as LiteralFloat;
                }
            }
        }

        public class LiteralDouble:CSharpDefinition
        {
            public static LiteralDouble Instance
            {
                get
                {
                    return new LiteralDouble().DefineAs(
                        R("double_literal")
                    ) as LiteralDouble;
                }
            }
        }

        public class LiteralDecimal:CSharpDefinition
        {
            public static LiteralDecimal Instance
            {
                get
                {
                    return new LiteralDecimal().DefineAs(
                        R("decimal_literal")
                    ) as LiteralDecimal;
                }
            }
        }

        public class LiteralCharacter:CSharpDefinition
        {
            public static LiteralCharacter Instance
            {
                get
                {
                    return new LiteralCharacter().DefineAs(
                        R("character_literal")
                    ) as LiteralCharacter;
                }
            }
        }

        public class LiteralString:CSharpDefinition
        {
            public static LiteralString Instance
            {
                get
                {
                    return new LiteralString().DefineAs(
                        R("string_literal")
                    ) as LiteralString;
                }
            }
        }

        public class Identifier:CSharpDefinition
        {
            public static Identifier Instance
            {
                get
                {
                    return new Identifier().DefineAs(
                        R("IDENTIFIER")
                    ) as Identifier;
                }
            }
        }

        public class CompilationUnit:CSharpDefinition
        {
            public static CompilationUnit Instance
            {
                get
                {
                    return new CompilationUnit().DefineAs(
                        ~N("UsingDirective")++ * ~N("NamespaceMemberDeclaration")++ * ~N("AttributeSection")++ * N("Eof")++
                    ) as CompilationUnit;
                }
            }
            public static CompilationUnit of(UsingDirective _usingdirective,NamespaceMemberDeclaration _namespacememberdeclaration,AttributeSection _attributesection,Eof _eof)
            {
                return CompilationUnit.Instance.AcceptClause(0,_usingdirective,_namespacememberdeclaration,_attributesection,_eof)as CompilationUnit;
            }
        }

        public class UsingDirective:CSharpDefinition
        {
            public static UsingDirective Instance
            {
                get
                {
                    return new UsingDirective().DefineAs(
                        N("UsingAliasDirective")
                        +
                        N("UsingNamespaceDirective")
                    ) as UsingDirective;
                }
            }
            public static UsingDirective of(UsingAliasDirective _usingaliasdirective)
            {
                return UsingDirective.Instance.AcceptClause(0,_usingaliasdirective)as UsingDirective;
            }
            public static UsingDirective of(UsingNamespaceDirective _usingnamespacedirective)
            {
                return UsingDirective.Instance.AcceptClause(1,_usingnamespacedirective)as UsingDirective;
            }
        }

        public class UsingAliasDirective:CSharpDefinition
        {
            public static UsingAliasDirective Instance
            {
                get
                {
                    return new UsingAliasDirective().DefineAs(
                        N("Using") * N("Identifier") * N("Assign") * N("NamespaceOrTypeName") * N("Semicolon")
                    ) as UsingAliasDirective;
                }
            }
            public static UsingAliasDirective of(Identifier _identifier,NamespaceOrTypeName _namespaceortypename)
            {
                return UsingAliasDirective.Instance.AcceptClause(0,Using.Instance,_identifier,Assign.Instance,_namespaceortypename,Semicolon.Instance)as UsingAliasDirective;
            }
        }

        public class UsingNamespaceDirective:CSharpDefinition
        {
            public static UsingNamespaceDirective Instance
            {
                get
                {
                    return new UsingNamespaceDirective().DefineAs(
                        N("Using") * N("NamespaceName") * N("Semicolon")
                    ) as UsingNamespaceDirective;
                }
            }
            public static UsingNamespaceDirective of(NamespaceName _namespacename)
            {
                return UsingNamespaceDirective.Instance.AcceptClause(0,Using.Instance,_namespacename,Semicolon.Instance)as UsingNamespaceDirective;
            }
        }

        public class NamespaceDeclaration:CSharpDefinition
        {
            public static NamespaceDeclaration Instance
            {
                get
                {
                    return new NamespaceDeclaration().DefineAs(
                        N("Namespace") * N("QualifiedIdentifier") * N("NamespaceBody") * N("Semicolon")++
                    ) as NamespaceDeclaration;
                }
            }
            public static NamespaceDeclaration of(QualifiedIdentifier _qualifiedidentifier,NamespaceBody _namespacebody)
            {
                return NamespaceDeclaration.Instance.AcceptClause(0,Namespace.Instance,_qualifiedidentifier,_namespacebody,Semicolon.Instance)as NamespaceDeclaration;
            }
        }

        public class QualifiedIdentifier:CSharpDefinition
        {
            public static QualifiedIdentifier Instance
            {
                get
                {
                    return new QualifiedIdentifier().DefineAs(
                        N("Identifier")
                        +
                        N("QualifiedIdentifier") * N("Dot") * N("Identifier")
                    ) as QualifiedIdentifier;
                }
            }
            public static QualifiedIdentifier of(Identifier _identifier)
            {
                return QualifiedIdentifier.Instance.AcceptClause(0,_identifier)as QualifiedIdentifier;
            }
            public static QualifiedIdentifier of(QualifiedIdentifier _qualifiedidentifier,Identifier _identifier)
            {
                return QualifiedIdentifier.Instance.AcceptClause(1,_qualifiedidentifier,Dot.Instance,_identifier)as QualifiedIdentifier;
            }
        }

        public class NamespaceName:CSharpDefinition
        {
            public static NamespaceName Instance
            {
                get
                {
                    return new NamespaceName().DefineAs(
                        N("NamespaceOrTypeName")
                    ) as NamespaceName;
                }
            }
            public static NamespaceName of(NamespaceOrTypeName _namespaceortypename)
            {
                return NamespaceName.Instance.AcceptClause(0,_namespaceortypename)as NamespaceName;
            }
        }

        public class NamespaceBody:CSharpDefinition
        {
            public static NamespaceBody Instance
            {
                get
                {
                    return new NamespaceBody().DefineAs(
                        N("OpenBrace") * ~N("UsingDirective")++ * ~N("NamespaceMemberDeclaration")++ * N("CloseBrace")
                    ) as NamespaceBody;
                }
            }
            public static NamespaceBody of(UsingDirective _usingdirective,NamespaceMemberDeclaration _namespacememberdeclaration)
            {
                return NamespaceBody.Instance.AcceptClause(0,OpenBrace.Instance,_usingdirective,_namespacememberdeclaration,CloseBrace.Instance)as NamespaceBody;
            }
        }

        public class NamespaceMemberDeclaration:CSharpDefinition
        {
            public static NamespaceMemberDeclaration Instance
            {
                get
                {
                    return new NamespaceMemberDeclaration().DefineAs(
                        N("TypeDeclaration")
                        +
                        N("NamespaceDeclaration")
                    ) as NamespaceMemberDeclaration;
                }
            }
            public static NamespaceMemberDeclaration of(TypeDeclaration _typedeclaration)
            {
                return NamespaceMemberDeclaration.Instance.AcceptClause(0,_typedeclaration)as NamespaceMemberDeclaration;
            }
            public static NamespaceMemberDeclaration of(NamespaceDeclaration _namespacedeclaration)
            {
                return NamespaceMemberDeclaration.Instance.AcceptClause(1,_namespacedeclaration)as NamespaceMemberDeclaration;
            }
        }

        public class TypeDeclaration:CSharpDefinition
        {
            public static TypeDeclaration Instance
            {
                get
                {
                    return new TypeDeclaration().DefineAs(
                        N("ClassDeclaration")
                        +
                        N("StructDeclaration")
                        +
                        N("InterfaceDeclaration")
                        +
                        N("EnumDeclaration")
                        +
                        N("DelegateDeclaration")
                    ) as TypeDeclaration;
                }
            }
            public static TypeDeclaration of(ClassDeclaration _classdeclaration)
            {
                return TypeDeclaration.Instance.AcceptClause(0,_classdeclaration)as TypeDeclaration;
            }
            public static TypeDeclaration of(StructDeclaration _structdeclaration)
            {
                return TypeDeclaration.Instance.AcceptClause(1,_structdeclaration)as TypeDeclaration;
            }
            public static TypeDeclaration of(InterfaceDeclaration _interfacedeclaration)
            {
                return TypeDeclaration.Instance.AcceptClause(2,_interfacedeclaration)as TypeDeclaration;
            }
            public static TypeDeclaration of(EnumDeclaration _enumdeclaration)
            {
                return TypeDeclaration.Instance.AcceptClause(3,_enumdeclaration)as TypeDeclaration;
            }
            public static TypeDeclaration of(DelegateDeclaration _delegatedeclaration)
            {
                return TypeDeclaration.Instance.AcceptClause(4,_delegatedeclaration)as TypeDeclaration;
            }
        }

        public class AttributeSection:CSharpDefinition
        {
            public static AttributeSection Instance
            {
                get
                {
                    return new AttributeSection().DefineAs(
                        N("OpenBracket") * N("AttributeTargetSpecifier") * N("AttributeList") * N("CloseBracket")
                        +
                        N("OpenBracket") * N("AttributeList") * N("CloseBracket")
                    ) as AttributeSection;
                }
            }
            public static AttributeSection of(AttributeTargetSpecifier _attributetargetspecifier,AttributeList _attributelist)
            {
                return AttributeSection.Instance.AcceptClause(0,OpenBracket.Instance,_attributetargetspecifier,_attributelist,CloseBracket.Instance)as AttributeSection;
            }
            public static AttributeSection of(AttributeList _attributelist)
            {
                return AttributeSection.Instance.AcceptClause(1,OpenBracket.Instance,_attributelist,CloseBracket.Instance)as AttributeSection;
            }
        }

        public class AttributeTargetSpecifier:CSharpDefinition
        {
            public static AttributeTargetSpecifier Instance
            {
                get
                {
                    return new AttributeTargetSpecifier().DefineAs(
                        N("AttributeTarget") * N("Colon")
                    ) as AttributeTargetSpecifier;
                }
            }
            public static AttributeTargetSpecifier of(AttributeTarget _attributetarget)
            {
                return AttributeTargetSpecifier.Instance.AcceptClause(0,_attributetarget,Colon.Instance)as AttributeTargetSpecifier;
            }
        }

        public class AttributeTarget:CSharpDefinition
        {
            public static AttributeTarget Instance
            {
                get
                {
                    return new AttributeTarget().DefineAs(
                        N("Identifier")
                        +
                        N("Event")
                        +
                        N("Return")
                    ) as AttributeTarget;
                }
            }
            public static AttributeTarget of(Identifier _identifier)
            {
                return AttributeTarget.Instance.AcceptClause(0,_identifier)as AttributeTarget;
            }
            public static AttributeTarget of(Event _event)
            {
                return AttributeTarget.Instance.AcceptClause(1,_event)as AttributeTarget;
            }
            public static AttributeTarget of(Return _return)
            {
                return AttributeTarget.Instance.AcceptClause(2,_return)as AttributeTarget;
            }
        }

        public class AttributeList:CSharpDefinition
        {
            public static AttributeList Instance
            {
                get
                {
                    return new AttributeList().DefineAs(
                        N("Attribute")
                        +
                        N("AttributeList") * N("Comma") * N("Attribute")
                    ) as AttributeList;
                }
            }
            public static AttributeList of(Attribute _attribute)
            {
                return AttributeList.Instance.AcceptClause(0,_attribute)as AttributeList;
            }
            public static AttributeList of(AttributeList _attributelist,Attribute _attribute)
            {
                return AttributeList.Instance.AcceptClause(1,_attributelist,Comma.Instance,_attribute)as AttributeList;
            }
        }

        public class Attribute:CSharpDefinition
        {
            public static Attribute Instance
            {
                get
                {
                    return new Attribute().DefineAs(
                        N("AttributeName") * N("AttributeArguments")++
                    ) as Attribute;
                }
            }
            public static Attribute of(AttributeName _attributename,AttributeArguments _attributearguments)
            {
                return Attribute.Instance.AcceptClause(0,_attributename,_attributearguments)as Attribute;
            }
        }

        public class AttributeName:CSharpDefinition
        {
            public static AttributeName Instance
            {
                get
                {
                    return new AttributeName().DefineAs(
                        N("QualifiedIdentifier")
                    ) as AttributeName;
                }
            }
            public static AttributeName of(QualifiedIdentifier _qualifiedidentifier)
            {
                return AttributeName.Instance.AcceptClause(0,_qualifiedidentifier)as AttributeName;
            }
        }

        public class AttributeArguments:CSharpDefinition
        {
            public static AttributeArguments Instance
            {
                get
                {
                    return new AttributeArguments().DefineAs(
                        N("PositionalArgumentList")
                        +
                        N("PositionalArgumentList") * N("Comma") * N("NamedArgumentList")
                        +
                        N("NamedArgumentList")
                    ) as AttributeArguments;
                }
            }
            public static AttributeArguments of(PositionalArgumentList _positionalargumentlist)
            {
                return AttributeArguments.Instance.AcceptClause(0,_positionalargumentlist)as AttributeArguments;
            }
            public static AttributeArguments of(PositionalArgumentList _positionalargumentlist,NamedArgumentList _namedargumentlist)
            {
                return AttributeArguments.Instance.AcceptClause(1,_positionalargumentlist,Comma.Instance,_namedargumentlist)as AttributeArguments;
            }
            public static AttributeArguments of(NamedArgumentList _namedargumentlist)
            {
                return AttributeArguments.Instance.AcceptClause(2,_namedargumentlist)as AttributeArguments;
            }
        }

        public class PositionalArgumentList:CSharpDefinition
        {
            public static PositionalArgumentList Instance
            {
                get
                {
                    return new PositionalArgumentList().DefineAs(
                        N("Expression")
                        +
                        N("PositionalArgumentList") * N("Comma") * N("Expression")
                    ) as PositionalArgumentList;
                }
            }
            public static PositionalArgumentList of(Expression _expression)
            {
                return PositionalArgumentList.Instance.AcceptClause(0,_expression)as PositionalArgumentList;
            }
            public static PositionalArgumentList of(PositionalArgumentList _positionalargumentlist,Expression _expression)
            {
                return PositionalArgumentList.Instance.AcceptClause(1,_positionalargumentlist,Comma.Instance,_expression)as PositionalArgumentList;
            }
        }

        public class NamedArgumentList:CSharpDefinition
        {
            public static NamedArgumentList Instance
            {
                get
                {
                    return new NamedArgumentList().DefineAs(
                        N("NamedArgument")
                        +
                        N("NamedArgumentList") * N("Comma") * N("NamedArgument")
                    ) as NamedArgumentList;
                }
            }
            public static NamedArgumentList of(NamedArgument _namedargument)
            {
                return NamedArgumentList.Instance.AcceptClause(0,_namedargument)as NamedArgumentList;
            }
            public static NamedArgumentList of(NamedArgumentList _namedargumentlist,NamedArgument _namedargument)
            {
                return NamedArgumentList.Instance.AcceptClause(1,_namedargumentlist,Comma.Instance,_namedargument)as NamedArgumentList;
            }
        }

        public class NamedArgument:CSharpDefinition
        {
            public static NamedArgument Instance
            {
                get
                {
                    return new NamedArgument().DefineAs(
                        N("Identifier") * N("Assign") * N("Expression")
                    ) as NamedArgument;
                }
            }
            public static NamedArgument of(Identifier _identifier,Expression _expression)
            {
                return NamedArgument.Instance.AcceptClause(0,_identifier,Assign.Instance,_expression)as NamedArgument;
            }
        }

        public class ClassBody:CSharpDefinition
        {
            public static ClassBody Instance
            {
                get
                {
                    return new ClassBody().DefineAs(
                        N("OpenBrace") * ~N("ClassMemberDeclaration")++ * N("CloseBrace")
                    ) as ClassBody;
                }
            }
            public static ClassBody of(ClassMemberDeclaration _classmemberdeclaration)
            {
                return ClassBody.Instance.AcceptClause(0,OpenBrace.Instance,_classmemberdeclaration,CloseBrace.Instance)as ClassBody;
            }
        }

        public class ClassMemberDeclaration:CSharpDefinition
        {
            public static ClassMemberDeclaration Instance
            {
                get
                {
                    return new ClassMemberDeclaration().DefineAs(
                        N("ConstantDeclaration")
                        +
                        N("FieldDeclaration")
                        +
                        N("MethodDeclaration")
                        +
                        N("PropertyDeclaration")
                        +
                        N("EventDeclaration")
                        +
                        N("IndexerDeclaration")
                        +
                        N("OperatorDeclaration")
                        +
                        N("ConstructorDeclaration")
                        +
                        N("DestructorDeclaration")
                        +
                        N("TypeDeclaration")
                    ) as ClassMemberDeclaration;
                }
            }
            public static ClassMemberDeclaration of(ConstantDeclaration _constantdeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(0,_constantdeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(FieldDeclaration _fielddeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(1,_fielddeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(MethodDeclaration _methoddeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(2,_methoddeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(PropertyDeclaration _propertydeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(3,_propertydeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(EventDeclaration _eventdeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(4,_eventdeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(IndexerDeclaration _indexerdeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(5,_indexerdeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(OperatorDeclaration _operatordeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(6,_operatordeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(ConstructorDeclaration _constructordeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(7,_constructordeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(DestructorDeclaration _destructordeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(8,_destructordeclaration)as ClassMemberDeclaration;
            }
            public static ClassMemberDeclaration of(TypeDeclaration _typedeclaration)
            {
                return ClassMemberDeclaration.Instance.AcceptClause(9,_typedeclaration)as ClassMemberDeclaration;
            }
        }

        public class StructDeclaration:CSharpDefinition
        {
            public static StructDeclaration Instance
            {
                get
                {
                    return new StructDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Struct") * N("Identifier") * ~N("StructInterface")++ * N("StructBody") * N("Semicolon")++
                    ) as StructDeclaration;
                }
            }
            public static StructDeclaration of(AttributeSection _attributesection,Modifier _modifier,Identifier _identifier,StructInterface _structinterface,StructBody _structbody)
            {
                return StructDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,Struct.Instance,_identifier,_structinterface,_structbody,Semicolon.Instance)as StructDeclaration;
            }
        }

        public class StructInterface:CSharpDefinition
        {
            public static StructInterface Instance
            {
                get
                {
                    return new StructInterface().DefineAs(
                        N("Colon") * N("TypeList")
                    ) as StructInterface;
                }
            }
            public static StructInterface of(TypeList _typelist)
            {
                return StructInterface.Instance.AcceptClause(0,Colon.Instance,_typelist)as StructInterface;
            }
        }

        public class StructBody:CSharpDefinition
        {
            public static StructBody Instance
            {
                get
                {
                    return new StructBody().DefineAs(
                        N("OpenBrace") * ~N("StructMemberDeclaration")++ * N("CloseBrace")
                    ) as StructBody;
                }
            }
            public static StructBody of(StructMemberDeclaration _structmemberdeclaration)
            {
                return StructBody.Instance.AcceptClause(0,OpenBrace.Instance,_structmemberdeclaration,CloseBrace.Instance)as StructBody;
            }
        }

        public class StructMemberDeclaration:CSharpDefinition
        {
            public static StructMemberDeclaration Instance
            {
                get
                {
                    return new StructMemberDeclaration().DefineAs(
                        N("ConstantDeclaration")
                        +
                        N("FieldDeclaration")
                        +
                        N("MethodDeclaration")
                        +
                        N("PropertyDeclaration")
                        +
                        N("EventDeclaration")
                        +
                        N("IndexerDeclaration")
                        +
                        N("OperatorDeclaration")
                        +
                        N("ConstructorDeclaration")
                        +
                        N("TypeDeclaration")
                        +
                        N("DestructorDeclaration")
                    ) as StructMemberDeclaration;
                }
            }
            public static StructMemberDeclaration of(ConstantDeclaration _constantdeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(0,_constantdeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(FieldDeclaration _fielddeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(1,_fielddeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(MethodDeclaration _methoddeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(2,_methoddeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(PropertyDeclaration _propertydeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(3,_propertydeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(EventDeclaration _eventdeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(4,_eventdeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(IndexerDeclaration _indexerdeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(5,_indexerdeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(OperatorDeclaration _operatordeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(6,_operatordeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(ConstructorDeclaration _constructordeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(7,_constructordeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(TypeDeclaration _typedeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(8,_typedeclaration)as StructMemberDeclaration;
            }
            public static StructMemberDeclaration of(DestructorDeclaration _destructordeclaration)
            {
                return StructMemberDeclaration.Instance.AcceptClause(9,_destructordeclaration)as StructMemberDeclaration;
            }
        }

        public class ConstantDeclaration:CSharpDefinition
        {
            public static ConstantDeclaration Instance
            {
                get
                {
                    return new ConstantDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier") * N("Const") * N("Type") * N("ConstantDeclarators") * N("Semicolon")
                    ) as ConstantDeclaration;
                }
            }
            public static ConstantDeclaration of(AttributeSection _attributesection,Modifier _modifier,Type _type,ConstantDeclarators _constantdeclarators)
            {
                return ConstantDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,Const.Instance,_type,_constantdeclarators,Semicolon.Instance)as ConstantDeclaration;
            }
        }

        public class ConstantDeclarators:CSharpDefinition
        {
            public static ConstantDeclarators Instance
            {
                get
                {
                    return new ConstantDeclarators().DefineAs(
                        N("ConstantDeclarator")
                        +
                        N("ConstantDeclarators") * N("Comma") * N("ConstantDeclarator")
                    ) as ConstantDeclarators;
                }
            }
            public static ConstantDeclarators of(ConstantDeclarator _constantdeclarator)
            {
                return ConstantDeclarators.Instance.AcceptClause(0,_constantdeclarator)as ConstantDeclarators;
            }
            public static ConstantDeclarators of(ConstantDeclarators _constantdeclarators,ConstantDeclarator _constantdeclarator)
            {
                return ConstantDeclarators.Instance.AcceptClause(1,_constantdeclarators,Comma.Instance,_constantdeclarator)as ConstantDeclarators;
            }
        }

        public class ConstantDeclarator:CSharpDefinition
        {
            public static ConstantDeclarator Instance
            {
                get
                {
                    return new ConstantDeclarator().DefineAs(
                        N("Identifier") * N("Assign") * N("ConstantExpression") * N("Comma")
                    ) as ConstantDeclarator;
                }
            }
            public static ConstantDeclarator of(Identifier _identifier,ConstantExpression _constantexpression)
            {
                return ConstantDeclarator.Instance.AcceptClause(0,_identifier,Assign.Instance,_constantexpression,Comma.Instance)as ConstantDeclarator;
            }
        }

        public class FieldDeclaration:CSharpDefinition
        {
            public static FieldDeclaration Instance
            {
                get
                {
                    return new FieldDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Type") * N("VariableDeclarators") * N("Semicolon")
                    ) as FieldDeclaration;
                }
            }
            public static FieldDeclaration of(AttributeSection _attributesection,Modifier _modifier,Type _type,VariableDeclarators _variabledeclarators)
            {
                return FieldDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,_type,_variabledeclarators,Semicolon.Instance)as FieldDeclaration;
            }
        }

        public class VariableDeclarators:CSharpDefinition
        {
            public static VariableDeclarators Instance
            {
                get
                {
                    return new VariableDeclarators().DefineAs(
                        N("VariableDeclarator")
                        +
                        N("VariableDeclarators") * N("Comma") * N("VariableDeclarator")
                    ) as VariableDeclarators;
                }
            }
            public static VariableDeclarators of(VariableDeclarator _variabledeclarator)
            {
                return VariableDeclarators.Instance.AcceptClause(0,_variabledeclarator)as VariableDeclarators;
            }
            public static VariableDeclarators of(VariableDeclarators _variabledeclarators,VariableDeclarator _variabledeclarator)
            {
                return VariableDeclarators.Instance.AcceptClause(1,_variabledeclarators,Comma.Instance,_variabledeclarator)as VariableDeclarators;
            }
        }

        public class VariableDeclarator:CSharpDefinition
        {
            public static VariableDeclarator Instance
            {
                get
                {
                    return new VariableDeclarator().DefineAs(
                        N("Identifier") * N("Assign") * N("VariableInitializer")
                        +
                        N("Identifier")
                    ) as VariableDeclarator;
                }
            }
            public static VariableDeclarator of(Identifier _identifier,VariableInitializer _variableinitializer)
            {
                return VariableDeclarator.Instance.AcceptClause(0,_identifier,Assign.Instance,_variableinitializer)as VariableDeclarator;
            }
            public static VariableDeclarator of(Identifier _identifier)
            {
                return VariableDeclarator.Instance.AcceptClause(1,_identifier)as VariableDeclarator;
            }
        }

        public class VariableInitializer:CSharpDefinition
        {
            public static VariableInitializer Instance
            {
                get
                {
                    return new VariableInitializer().DefineAs(
                        N("Expression")
                        +
                        N("ArrayInitializer")
                        +
                        N("Stackalloc") * N("Type") * N("OpenBracket") * N("Expression") * N("CloseBracket")
                    ) as VariableInitializer;
                }
            }
            public static VariableInitializer of(Expression _expression)
            {
                return VariableInitializer.Instance.AcceptClause(0,_expression)as VariableInitializer;
            }
            public static VariableInitializer of(ArrayInitializer _arrayinitializer)
            {
                return VariableInitializer.Instance.AcceptClause(1,_arrayinitializer)as VariableInitializer;
            }
            public static VariableInitializer of(Type _type,Expression _expression)
            {
                return VariableInitializer.Instance.AcceptClause(2,Stackalloc.Instance,_type,OpenBracket.Instance,_expression,CloseBracket.Instance)as VariableInitializer;
            }
        }

        public class MethodDeclaration:CSharpDefinition
        {
            public static MethodDeclaration Instance
            {
                get
                {
                    return new MethodDeclaration().DefineAs(
                        N("MethodHeader") * N("MethodBody")
                    ) as MethodDeclaration;
                }
            }
            public static MethodDeclaration of(MethodHeader _methodheader,MethodBody _methodbody)
            {
                return MethodDeclaration.Instance.AcceptClause(0,_methodheader,_methodbody)as MethodDeclaration;
            }
        }

        public class MethodHeader:CSharpDefinition
        {
            public static MethodHeader Instance
            {
                get
                {
                    return new MethodHeader().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("ReturnType") * N("MemberName") * N("OpenParens") * N("FormalParameterList")++ * N("CloseParens")
                        +
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Void") * N("MemberName") * N("OpenParens") * N("FormalParameterList")++ * N("CloseParens")
                    ) as MethodHeader;
                }
            }
            public static MethodHeader of(AttributeSection _attributesection,Modifier _modifier,ReturnType _returntype,MemberName _membername,FormalParameterList _formalparameterlist)
            {
                return MethodHeader.Instance.AcceptClause(0,_attributesection,_modifier,_returntype,_membername,OpenParens.Instance,_formalparameterlist,CloseParens.Instance)as MethodHeader;
            }
            public static MethodHeader of(AttributeSection _attributesection,Modifier _modifier,MemberName _membername,FormalParameterList _formalparameterlist)
            {
                return MethodHeader.Instance.AcceptClause(1,_attributesection,_modifier,Void.Instance,_membername,OpenParens.Instance,_formalparameterlist,CloseParens.Instance)as MethodHeader;
            }
        }

        public class MethodBody:CSharpDefinition
        {
            public static MethodBody Instance
            {
                get
                {
                    return new MethodBody().DefineAs(
                        N("Block")
                        +
                        N("Semicolon")
                    ) as MethodBody;
                }
            }
            public static MethodBody of(Block _block)
            {
                return MethodBody.Instance.AcceptClause(0,_block)as MethodBody;
            }
            public static MethodBody of(Semicolon _semicolon)
            {
                return MethodBody.Instance.AcceptClause(1,_semicolon)as MethodBody;
            }
        }

        public class FormalParameterList:CSharpDefinition
        {
            public static FormalParameterList Instance
            {
                get
                {
                    return new FormalParameterList().DefineAs(
                        N("FixedParameters")
                        +
                        N("FixedParameters") * N("Comma") * N("ParameterArray")
                        +
                        N("ParameterArray")
                    ) as FormalParameterList;
                }
            }
            public static FormalParameterList of(FixedParameters _fixedparameters)
            {
                return FormalParameterList.Instance.AcceptClause(0,_fixedparameters)as FormalParameterList;
            }
            public static FormalParameterList of(FixedParameters _fixedparameters,ParameterArray _parameterarray)
            {
                return FormalParameterList.Instance.AcceptClause(1,_fixedparameters,Comma.Instance,_parameterarray)as FormalParameterList;
            }
            public static FormalParameterList of(ParameterArray _parameterarray)
            {
                return FormalParameterList.Instance.AcceptClause(2,_parameterarray)as FormalParameterList;
            }
        }

        public class FixedParameters:CSharpDefinition
        {
            public static FixedParameters Instance
            {
                get
                {
                    return new FixedParameters().DefineAs(
                        N("FixedParameter")
                        +
                        N("FixedParameters") * N("Comma") * N("FixedParameter")
                    ) as FixedParameters;
                }
            }
            public static FixedParameters of(FixedParameter _fixedparameter)
            {
                return FixedParameters.Instance.AcceptClause(0,_fixedparameter)as FixedParameters;
            }
            public static FixedParameters of(FixedParameters _fixedparameters,FixedParameter _fixedparameter)
            {
                return FixedParameters.Instance.AcceptClause(1,_fixedparameters,Comma.Instance,_fixedparameter)as FixedParameters;
            }
        }

        public class FixedParameter:CSharpDefinition
        {
            public static FixedParameter Instance
            {
                get
                {
                    return new FixedParameter().DefineAs(
                        ~N("AttributeSection")++ * N("ParameterModifier")++ * N("Type") * N("Identifier")
                    ) as FixedParameter;
                }
            }
            public static FixedParameter of(AttributeSection _attributesection,ParameterModifier _parametermodifier,Type _type,Identifier _identifier)
            {
                return FixedParameter.Instance.AcceptClause(0,_attributesection,_parametermodifier,_type,_identifier)as FixedParameter;
            }
        }

        public class ParameterModifier:CSharpDefinition
        {
            public static ParameterModifier Instance
            {
                get
                {
                    return new ParameterModifier().DefineAs(
                        N("Ref")
                        +
                        N("Out")
                    ) as ParameterModifier;
                }
            }
            public static ParameterModifier of(Ref _ref)
            {
                return ParameterModifier.Instance.AcceptClause(0,_ref)as ParameterModifier;
            }
            public static ParameterModifier of(Out _out)
            {
                return ParameterModifier.Instance.AcceptClause(1,_out)as ParameterModifier;
            }
        }

        public class ParameterArray:CSharpDefinition
        {
            public static ParameterArray Instance
            {
                get
                {
                    return new ParameterArray().DefineAs(
                        ~N("AttributeSection")++ * N("Params") * N("Type") * N("Identifier")
                    ) as ParameterArray;
                }
            }
            public static ParameterArray of(AttributeSection _attributesection,Type _type,Identifier _identifier)
            {
                return ParameterArray.Instance.AcceptClause(0,_attributesection,Params.Instance,_type,_identifier)as ParameterArray;
            }
        }

        public class MemberName:CSharpDefinition
        {
            public static MemberName Instance
            {
                get
                {
                    return new MemberName().DefineAs(
                        N("QualifiedIdentifier")
                    ) as MemberName;
                }
            }
            public static MemberName of(QualifiedIdentifier _qualifiedidentifier)
            {
                return MemberName.Instance.AcceptClause(0,_qualifiedidentifier)as MemberName;
            }
        }

        public class PropertyDeclaration:CSharpDefinition
        {
            public static PropertyDeclaration Instance
            {
                get
                {
                    return new PropertyDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Type") * N("MemberName") * N("OpenBrace") * N("AccessorDeclarations") * N("CloseBrace")
                    ) as PropertyDeclaration;
                }
            }
            public static PropertyDeclaration of(AttributeSection _attributesection,Modifier _modifier,Type _type,MemberName _membername,AccessorDeclarations _accessordeclarations)
            {
                return PropertyDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,_type,_membername,OpenBrace.Instance,_accessordeclarations,CloseBrace.Instance)as PropertyDeclaration;
            }
        }

        public class AccessorDeclarations:CSharpDefinition
        {
            public static AccessorDeclarations Instance
            {
                get
                {
                    return new AccessorDeclarations().DefineAs(
                        N("GetAccessorDeclaration") * N("SetAccessorDeclaration")++
                        +
                        N("SetAccessorDeclaration") * N("GetAccessorDeclaration")++
                    ) as AccessorDeclarations;
                }
            }
            public static AccessorDeclarations of(GetAccessorDeclaration _getaccessordeclaration,SetAccessorDeclaration _setaccessordeclaration)
            {
                return AccessorDeclarations.Instance.AcceptClause(0,_getaccessordeclaration,_setaccessordeclaration)as AccessorDeclarations;
            }
            public static AccessorDeclarations of(SetAccessorDeclaration _setaccessordeclaration,GetAccessorDeclaration _getaccessordeclaration)
            {
                return AccessorDeclarations.Instance.AcceptClause(1,_setaccessordeclaration,_getaccessordeclaration)as AccessorDeclarations;
            }
        }

        public class GetAccessorDeclaration:CSharpDefinition
        {
            public static GetAccessorDeclaration Instance
            {
                get
                {
                    return new GetAccessorDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("Get") * N("AccessorBody")
                    ) as GetAccessorDeclaration;
                }
            }
            public static GetAccessorDeclaration of(AttributeSection _attributesection,AccessorBody _accessorbody)
            {
                return GetAccessorDeclaration.Instance.AcceptClause(0,_attributesection,Get.Instance,_accessorbody)as GetAccessorDeclaration;
            }
        }

        public class SetAccessorDeclaration:CSharpDefinition
        {
            public static SetAccessorDeclaration Instance
            {
                get
                {
                    return new SetAccessorDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("Set") * N("AccessorBody")
                    ) as SetAccessorDeclaration;
                }
            }
            public static SetAccessorDeclaration of(AttributeSection _attributesection,AccessorBody _accessorbody)
            {
                return SetAccessorDeclaration.Instance.AcceptClause(0,_attributesection,Set.Instance,_accessorbody)as SetAccessorDeclaration;
            }
        }

        public class AccessorBody:CSharpDefinition
        {
            public static AccessorBody Instance
            {
                get
                {
                    return new AccessorBody().DefineAs(
                        N("Block")
                        +
                        N("Semicolon")
                    ) as AccessorBody;
                }
            }
            public static AccessorBody of(Block _block)
            {
                return AccessorBody.Instance.AcceptClause(0,_block)as AccessorBody;
            }
            public static AccessorBody of(Semicolon _semicolon)
            {
                return AccessorBody.Instance.AcceptClause(1,_semicolon)as AccessorBody;
            }
        }

        public class InterfaceDeclaration:CSharpDefinition
        {
            public static InterfaceDeclaration Instance
            {
                get
                {
                    return new InterfaceDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Interface") * N("Identifier") * N("InterfaceBase")++ * N("InterfaceBody")
                    ) as InterfaceDeclaration;
                }
            }
            public static InterfaceDeclaration of(AttributeSection _attributesection,Modifier _modifier,Identifier _identifier,InterfaceBase _interfacebase,InterfaceBody _interfacebody)
            {
                return InterfaceDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,Interface.Instance,_identifier,_interfacebase,_interfacebody)as InterfaceDeclaration;
            }
        }

        public class InterfaceBase:CSharpDefinition
        {
            public static InterfaceBase Instance
            {
                get
                {
                    return new InterfaceBase().DefineAs(
                        N("Colon") * N("InterfaceTypeList")
                    ) as InterfaceBase;
                }
            }
            public static InterfaceBase of(InterfaceTypeList _interfacetypelist)
            {
                return InterfaceBase.Instance.AcceptClause(0,Colon.Instance,_interfacetypelist)as InterfaceBase;
            }
        }

        public class InterfaceTypeList:CSharpDefinition
        {
            public static InterfaceTypeList Instance
            {
                get
                {
                    return new InterfaceTypeList().DefineAs(
                        N("InterfaceType")
                        +
                        N("InterfaceTypeList") * N("Comma") * N("InterfaceType")
                    ) as InterfaceTypeList;
                }
            }
            public static InterfaceTypeList of(InterfaceType _interfacetype)
            {
                return InterfaceTypeList.Instance.AcceptClause(0,_interfacetype)as InterfaceTypeList;
            }
            public static InterfaceTypeList of(InterfaceTypeList _interfacetypelist,InterfaceType _interfacetype)
            {
                return InterfaceTypeList.Instance.AcceptClause(1,_interfacetypelist,Comma.Instance,_interfacetype)as InterfaceTypeList;
            }
        }

        public class InterfaceBody:CSharpDefinition
        {
            public static InterfaceBody Instance
            {
                get
                {
                    return new InterfaceBody().DefineAs(
                        N("OpenBrace") * ~N("InterfaceMemberDeclaration")++ * N("CloseBrace")
                    ) as InterfaceBody;
                }
            }
            public static InterfaceBody of(InterfaceMemberDeclaration _interfacememberdeclaration)
            {
                return InterfaceBody.Instance.AcceptClause(0,OpenBrace.Instance,_interfacememberdeclaration,CloseBrace.Instance)as InterfaceBody;
            }
        }

        public class InterfaceMemberDeclaration:CSharpDefinition
        {
            public static InterfaceMemberDeclaration Instance
            {
                get
                {
                    return new InterfaceMemberDeclaration().DefineAs(
                        N("InterfaceMethodDeclaration")
                        +
                        N("InterfacePropertyDeclaration")
                        +
                        N("InterfaceEventDeclaration")
                        +
                        N("InterfaceIndexerDeclaration")
                    ) as InterfaceMemberDeclaration;
                }
            }
            public static InterfaceMemberDeclaration of(InterfaceMethodDeclaration _interfacemethoddeclaration)
            {
                return InterfaceMemberDeclaration.Instance.AcceptClause(0,_interfacemethoddeclaration)as InterfaceMemberDeclaration;
            }
            public static InterfaceMemberDeclaration of(InterfacePropertyDeclaration _interfacepropertydeclaration)
            {
                return InterfaceMemberDeclaration.Instance.AcceptClause(1,_interfacepropertydeclaration)as InterfaceMemberDeclaration;
            }
            public static InterfaceMemberDeclaration of(InterfaceEventDeclaration _interfaceeventdeclaration)
            {
                return InterfaceMemberDeclaration.Instance.AcceptClause(2,_interfaceeventdeclaration)as InterfaceMemberDeclaration;
            }
            public static InterfaceMemberDeclaration of(InterfaceIndexerDeclaration _interfaceindexerdeclaration)
            {
                return InterfaceMemberDeclaration.Instance.AcceptClause(3,_interfaceindexerdeclaration)as InterfaceMemberDeclaration;
            }
        }

        public class InterfaceMethodDeclaration:CSharpDefinition
        {
            public static InterfaceMethodDeclaration Instance
            {
                get
                {
                    return new InterfaceMethodDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("New")++ * N("Type") * N("Identifier") * N("OpenParens") * N("FormalParameterList")++ * N("CloseParens") * N("Semicolon")
                        +
                        ~N("AttributeSection")++ * N("New")++ * N("Void") * N("Identifier") * N("OpenParens") * N("FormalParameterList")++ * N("CloseParens") * N("Semicolon")
                    ) as InterfaceMethodDeclaration;
                }
            }
            public static InterfaceMethodDeclaration of(AttributeSection _attributesection,Type _type,Identifier _identifier,FormalParameterList _formalparameterlist)
            {
                return InterfaceMethodDeclaration.Instance.AcceptClause(0,_attributesection,New.Instance,_type,_identifier,OpenParens.Instance,_formalparameterlist,CloseParens.Instance,Semicolon.Instance)as InterfaceMethodDeclaration;
            }
            public static InterfaceMethodDeclaration of(AttributeSection _attributesection,Identifier _identifier,FormalParameterList _formalparameterlist)
            {
                return InterfaceMethodDeclaration.Instance.AcceptClause(1,_attributesection,New.Instance,Void.Instance,_identifier,OpenParens.Instance,_formalparameterlist,CloseParens.Instance,Semicolon.Instance)as InterfaceMethodDeclaration;
            }
        }

        public class InterfacePropertyDeclaration:CSharpDefinition
        {
            public static InterfacePropertyDeclaration Instance
            {
                get
                {
                    return new InterfacePropertyDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("New")++ * N("Type") * N("Identifier") * N("OpenBrace") * N("InterfaceAccesors") * N("CloseBrace")
                    ) as InterfacePropertyDeclaration;
                }
            }
            public static InterfacePropertyDeclaration of(AttributeSection _attributesection,Type _type,Identifier _identifier,InterfaceAccesors _interfaceaccesors)
            {
                return InterfacePropertyDeclaration.Instance.AcceptClause(0,_attributesection,New.Instance,_type,_identifier,OpenBrace.Instance,_interfaceaccesors,CloseBrace.Instance)as InterfacePropertyDeclaration;
            }
        }

        public class InterfaceAccesors:CSharpDefinition
        {
            public static InterfaceAccesors Instance
            {
                get
                {
                    return new InterfaceAccesors().DefineAs(
                        N("InterfaceAccessorGet")
                        +
                        N("InterfaceAccessorSet")
                        +
                        N("InterfaceAccessorGet") * N("InterfaceAccessorSet")
                        +
                        N("InterfaceAccessorSet") * N("InterfaceAccessorGet")
                    ) as InterfaceAccesors;
                }
            }
            public static InterfaceAccesors of(InterfaceAccessorGet _interfaceaccessorget)
            {
                return InterfaceAccesors.Instance.AcceptClause(0,_interfaceaccessorget)as InterfaceAccesors;
            }
            public static InterfaceAccesors of(InterfaceAccessorSet _interfaceaccessorset)
            {
                return InterfaceAccesors.Instance.AcceptClause(1,_interfaceaccessorset)as InterfaceAccesors;
            }
            public static InterfaceAccesors of(InterfaceAccessorGet _interfaceaccessorget,InterfaceAccessorSet _interfaceaccessorset)
            {
                return InterfaceAccesors.Instance.AcceptClause(2,_interfaceaccessorget,_interfaceaccessorset)as InterfaceAccesors;
            }
            public static InterfaceAccesors of(InterfaceAccessorSet _interfaceaccessorset,InterfaceAccessorGet _interfaceaccessorget)
            {
                return InterfaceAccesors.Instance.AcceptClause(3,_interfaceaccessorset,_interfaceaccessorget)as InterfaceAccesors;
            }
        }

        public class InterfaceAccessorGet:CSharpDefinition
        {
            public static InterfaceAccessorGet Instance
            {
                get
                {
                    return new InterfaceAccessorGet().DefineAs(
                        ~N("AttributeSection")++ * N("Get") * N("Semicolon")
                    ) as InterfaceAccessorGet;
                }
            }
            public static InterfaceAccessorGet of(AttributeSection _attributesection)
            {
                return InterfaceAccessorGet.Instance.AcceptClause(0,_attributesection,Get.Instance,Semicolon.Instance)as InterfaceAccessorGet;
            }
        }

        public class InterfaceAccessorSet:CSharpDefinition
        {
            public static InterfaceAccessorSet Instance
            {
                get
                {
                    return new InterfaceAccessorSet().DefineAs(
                        ~N("AttributeSection")++ * N("Set") * N("Semicolon")
                    ) as InterfaceAccessorSet;
                }
            }
            public static InterfaceAccessorSet of(AttributeSection _attributesection)
            {
                return InterfaceAccessorSet.Instance.AcceptClause(0,_attributesection,Set.Instance,Semicolon.Instance)as InterfaceAccessorSet;
            }
        }

        public class InterfaceEventDeclaration:CSharpDefinition
        {
            public static InterfaceEventDeclaration Instance
            {
                get
                {
                    return new InterfaceEventDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("New")++ * N("Event") * N("Type") * N("Identifier") * N("Semicolon")
                    ) as InterfaceEventDeclaration;
                }
            }
            public static InterfaceEventDeclaration of(AttributeSection _attributesection,Type _type,Identifier _identifier)
            {
                return InterfaceEventDeclaration.Instance.AcceptClause(0,_attributesection,New.Instance,Event.Instance,_type,_identifier,Semicolon.Instance)as InterfaceEventDeclaration;
            }
        }

        public class InterfaceIndexerDeclaration:CSharpDefinition
        {
            public static InterfaceIndexerDeclaration Instance
            {
                get
                {
                    return new InterfaceIndexerDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("New")++ * N("Type") * N("This") * N("OpenBracket") * N("FormalParameterList")++ * N("CloseBracket") * N("OpenBrace") * N("InterfaceAccesors") * N("CloseBrace")
                    ) as InterfaceIndexerDeclaration;
                }
            }
            public static InterfaceIndexerDeclaration of(AttributeSection _attributesection,Type _type,FormalParameterList _formalparameterlist,InterfaceAccesors _interfaceaccesors)
            {
                return InterfaceIndexerDeclaration.Instance.AcceptClause(0,_attributesection,New.Instance,_type,This.Instance,OpenBracket.Instance,_formalparameterlist,CloseBracket.Instance,OpenBrace.Instance,_interfaceaccesors,CloseBrace.Instance)as InterfaceIndexerDeclaration;
            }
        }

        public class OperatorDeclaration:CSharpDefinition
        {
            public static OperatorDeclaration Instance
            {
                get
                {
                    return new OperatorDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("OperatorDeclarator") * N("Block")
                    ) as OperatorDeclaration;
                }
            }
            public static OperatorDeclaration of(AttributeSection _attributesection,Modifier _modifier,OperatorDeclarator _operatordeclarator,Block _block)
            {
                return OperatorDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,_operatordeclarator,_block)as OperatorDeclaration;
            }
        }

        public class OperatorDeclarator:CSharpDefinition
        {
            public static OperatorDeclarator Instance
            {
                get
                {
                    return new OperatorDeclarator().DefineAs(
                        N("ReturnType") * N("Operator") * N("OverloadableOperator") * N("OpenParens") * N("Type") * N("Identifier") * N("CloseParens")
                        +
                        N("ReturnType") * N("Operator") * N("OverloadableOperator") * N("OpenParens") * N("LeftType") * N("LeftParam") * N("Comma") * N("RightType") * N("RightParam") * N("CloseParens")
                        +
                        N("ConversionOperatorDeclarator")
                    ) as OperatorDeclarator;
                }
            }
            public static OperatorDeclarator of(ReturnType _returntype,OverloadableOperator _overloadableoperator,Type _type,Identifier _identifier)
            {
                return OperatorDeclarator.Instance.AcceptClause(0,_returntype,Operator.Instance,_overloadableoperator,OpenParens.Instance,_type,_identifier,CloseParens.Instance)as OperatorDeclarator;
            }
            public static OperatorDeclarator of(ReturnType _returntype,OverloadableOperator _overloadableoperator,LeftType _lefttype,LeftParam _leftparam,RightType _righttype,RightParam _rightparam)
            {
                return OperatorDeclarator.Instance.AcceptClause(1,_returntype,Operator.Instance,_overloadableoperator,OpenParens.Instance,_lefttype,_leftparam,Comma.Instance,_righttype,_rightparam,CloseParens.Instance)as OperatorDeclarator;
            }
            public static OperatorDeclarator of(ConversionOperatorDeclarator _conversionoperatordeclarator)
            {
                return OperatorDeclarator.Instance.AcceptClause(2,_conversionoperatordeclarator)as OperatorDeclarator;
            }
        }

        public class LeftType:CSharpDefinition
        {
            public static LeftType Instance
            {
                get
                {
                    return new LeftType().DefineAs(
                        N("Type")
                    ) as LeftType;
                }
            }
            public static LeftType of(Type _type)
            {
                return LeftType.Instance.AcceptClause(0,_type)as LeftType;
            }
        }

        public class RightType:CSharpDefinition
        {
            public static RightType Instance
            {
                get
                {
                    return new RightType().DefineAs(
                        N("Type")
                    ) as RightType;
                }
            }
            public static RightType of(Type _type)
            {
                return RightType.Instance.AcceptClause(0,_type)as RightType;
            }
        }

        public class ReturnType:CSharpDefinition
        {
            public static ReturnType Instance
            {
                get
                {
                    return new ReturnType().DefineAs(
                        N("Type")
                    ) as ReturnType;
                }
            }
            public static ReturnType of(Type _type)
            {
                return ReturnType.Instance.AcceptClause(0,_type)as ReturnType;
            }
        }

        public class LeftParam:CSharpDefinition
        {
            public static LeftParam Instance
            {
                get
                {
                    return new LeftParam().DefineAs(
                        N("Identifier")
                    ) as LeftParam;
                }
            }
            public static LeftParam of(Identifier _identifier)
            {
                return LeftParam.Instance.AcceptClause(0,_identifier)as LeftParam;
            }
        }

        public class RightParam:CSharpDefinition
        {
            public static RightParam Instance
            {
                get
                {
                    return new RightParam().DefineAs(
                        N("Identifier")
                    ) as RightParam;
                }
            }
            public static RightParam of(Identifier _identifier)
            {
                return RightParam.Instance.AcceptClause(0,_identifier)as RightParam;
            }
        }

        public class OverloadableOperator:CSharpDefinition
        {
            public static OverloadableOperator Instance
            {
                get
                {
                    return new OverloadableOperator().DefineAs(
                        N("Bang")
                        +
                        N("Tilde")
                        +
                        N("OpInc")
                        +
                        N("OpDec")
                        +
                        N("True")
                        +
                        N("False")
                        +
                        N("Plus")
                        +
                        N("Minus")
                        +
                        N("Star")
                        +
                        N("Div")
                        +
                        N("Percent")
                        +
                        N("BitwiseAnd")
                        +
                        N("BitwiseOr")
                        +
                        N("Carret")
                        +
                        N("OpShiftLeft")
                        +
                        N("OpShiftRight")
                        +
                        N("OpEq")
                        +
                        N("OpNe")
                        +
                        N("OpGt")
                        +
                        N("OpLt")
                        +
                        N("OpGe")
                        +
                        N("OpLe")
                    ) as OverloadableOperator;
                }
            }
            public static OverloadableOperator of(Bang _bang)
            {
                return OverloadableOperator.Instance.AcceptClause(0,_bang)as OverloadableOperator;
            }
            public static OverloadableOperator of(Tilde _tilde)
            {
                return OverloadableOperator.Instance.AcceptClause(1,_tilde)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpInc _opinc)
            {
                return OverloadableOperator.Instance.AcceptClause(2,_opinc)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpDec _opdec)
            {
                return OverloadableOperator.Instance.AcceptClause(3,_opdec)as OverloadableOperator;
            }
            public static OverloadableOperator of(True _true)
            {
                return OverloadableOperator.Instance.AcceptClause(4,_true)as OverloadableOperator;
            }
            public static OverloadableOperator of(False _false)
            {
                return OverloadableOperator.Instance.AcceptClause(5,_false)as OverloadableOperator;
            }
            public static OverloadableOperator of(Plus _plus)
            {
                return OverloadableOperator.Instance.AcceptClause(6,_plus)as OverloadableOperator;
            }
            public static OverloadableOperator of(Minus _minus)
            {
                return OverloadableOperator.Instance.AcceptClause(7,_minus)as OverloadableOperator;
            }
            public static OverloadableOperator of(Star _star)
            {
                return OverloadableOperator.Instance.AcceptClause(8,_star)as OverloadableOperator;
            }
            public static OverloadableOperator of(Div _div)
            {
                return OverloadableOperator.Instance.AcceptClause(9,_div)as OverloadableOperator;
            }
            public static OverloadableOperator of(Percent _percent)
            {
                return OverloadableOperator.Instance.AcceptClause(10,_percent)as OverloadableOperator;
            }
            public static OverloadableOperator of(BitwiseAnd _bitwiseand)
            {
                return OverloadableOperator.Instance.AcceptClause(11,_bitwiseand)as OverloadableOperator;
            }
            public static OverloadableOperator of(BitwiseOr _bitwiseor)
            {
                return OverloadableOperator.Instance.AcceptClause(12,_bitwiseor)as OverloadableOperator;
            }
            public static OverloadableOperator of(Carret _carret)
            {
                return OverloadableOperator.Instance.AcceptClause(13,_carret)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpShiftLeft _opshiftleft)
            {
                return OverloadableOperator.Instance.AcceptClause(14,_opshiftleft)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpShiftRight _opshiftright)
            {
                return OverloadableOperator.Instance.AcceptClause(15,_opshiftright)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpEq _opeq)
            {
                return OverloadableOperator.Instance.AcceptClause(16,_opeq)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpNe _opne)
            {
                return OverloadableOperator.Instance.AcceptClause(17,_opne)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpGt _opgt)
            {
                return OverloadableOperator.Instance.AcceptClause(18,_opgt)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpLt _oplt)
            {
                return OverloadableOperator.Instance.AcceptClause(19,_oplt)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpGe _opge)
            {
                return OverloadableOperator.Instance.AcceptClause(20,_opge)as OverloadableOperator;
            }
            public static OverloadableOperator of(OpLe _ople)
            {
                return OverloadableOperator.Instance.AcceptClause(21,_ople)as OverloadableOperator;
            }
        }

        public class ConversionOperatorDeclarator:CSharpDefinition
        {
            public static ConversionOperatorDeclarator Instance
            {
                get
                {
                    return new ConversionOperatorDeclarator().DefineAs(
                        N("ConversionImplicit")
                        +
                        N("ConversionExplicit")
                    ) as ConversionOperatorDeclarator;
                }
            }
            public static ConversionOperatorDeclarator of(ConversionImplicit _conversionimplicit)
            {
                return ConversionOperatorDeclarator.Instance.AcceptClause(0,_conversionimplicit)as ConversionOperatorDeclarator;
            }
            public static ConversionOperatorDeclarator of(ConversionExplicit _conversionexplicit)
            {
                return ConversionOperatorDeclarator.Instance.AcceptClause(1,_conversionexplicit)as ConversionOperatorDeclarator;
            }
        }

        public class ConversionImplicit:CSharpDefinition
        {
            public static ConversionImplicit Instance
            {
                get
                {
                    return new ConversionImplicit().DefineAs(
                        N("Implicit") * N("Operator") * N("ReturnType") * N("OpenParens") * N("Type") * N("Identifier") * N("CloseParens")
                    ) as ConversionImplicit;
                }
            }
            public static ConversionImplicit of(ReturnType _returntype,Type _type,Identifier _identifier)
            {
                return ConversionImplicit.Instance.AcceptClause(0,Implicit.Instance,Operator.Instance,_returntype,OpenParens.Instance,_type,_identifier,CloseParens.Instance)as ConversionImplicit;
            }
        }

        public class ConversionExplicit:CSharpDefinition
        {
            public static ConversionExplicit Instance
            {
                get
                {
                    return new ConversionExplicit().DefineAs(
                        N("Explicit") * N("Operator") * N("ReturnType") * N("OpenParens") * N("Type") * N("Identifier") * N("CloseParens")
                    ) as ConversionExplicit;
                }
            }
            public static ConversionExplicit of(ReturnType _returntype,Type _type,Identifier _identifier)
            {
                return ConversionExplicit.Instance.AcceptClause(0,Explicit.Instance,Operator.Instance,_returntype,OpenParens.Instance,_type,_identifier,CloseParens.Instance)as ConversionExplicit;
            }
        }

        public class ConstructorDeclaration:CSharpDefinition
        {
            public static ConstructorDeclaration Instance
            {
                get
                {
                    return new ConstructorDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("ConstructorDeclarator") * N("Block")
                    ) as ConstructorDeclaration;
                }
            }
            public static ConstructorDeclaration of(AttributeSection _attributesection,Modifier _modifier,ConstructorDeclarator _constructordeclarator,Block _block)
            {
                return ConstructorDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,_constructordeclarator,_block)as ConstructorDeclaration;
            }
        }

        public class ConstructorDeclarator:CSharpDefinition
        {
            public static ConstructorDeclarator Instance
            {
                get
                {
                    return new ConstructorDeclarator().DefineAs(
                        N("Identifier") * N("OpenParens") * N("FormalParameterList")++ * N("CloseParens") * N("ConstructorInitializer")++
                    ) as ConstructorDeclarator;
                }
            }
            public static ConstructorDeclarator of(Identifier _identifier,FormalParameterList _formalparameterlist,ConstructorInitializer _constructorinitializer)
            {
                return ConstructorDeclarator.Instance.AcceptClause(0,_identifier,OpenParens.Instance,_formalparameterlist,CloseParens.Instance,_constructorinitializer)as ConstructorDeclarator;
            }
        }

        public class ConstructorInitializer:CSharpDefinition
        {
            public static ConstructorInitializer Instance
            {
                get
                {
                    return new ConstructorInitializer().DefineAs(
                        N("ConstructorInitializerBase")
                        +
                        N("ConstructorInitializerThis")
                    ) as ConstructorInitializer;
                }
            }
            public static ConstructorInitializer of(ConstructorInitializerBase _constructorinitializerbase)
            {
                return ConstructorInitializer.Instance.AcceptClause(0,_constructorinitializerbase)as ConstructorInitializer;
            }
            public static ConstructorInitializer of(ConstructorInitializerThis _constructorinitializerthis)
            {
                return ConstructorInitializer.Instance.AcceptClause(1,_constructorinitializerthis)as ConstructorInitializer;
            }
        }

        public class ConstructorInitializerBase:CSharpDefinition
        {
            public static ConstructorInitializerBase Instance
            {
                get
                {
                    return new ConstructorInitializerBase().DefineAs(
                        N("Colon") * N("Base") * N("OpenParens") * N("ArgumentList")++ * N("CloseParens")
                    ) as ConstructorInitializerBase;
                }
            }
            public static ConstructorInitializerBase of(ArgumentList _argumentlist)
            {
                return ConstructorInitializerBase.Instance.AcceptClause(0,Colon.Instance,Base.Instance,OpenParens.Instance,_argumentlist,CloseParens.Instance)as ConstructorInitializerBase;
            }
        }

        public class ConstructorInitializerThis:CSharpDefinition
        {
            public static ConstructorInitializerThis Instance
            {
                get
                {
                    return new ConstructorInitializerThis().DefineAs(
                        N("Colon") * N("This") * N("OpenParens") * N("ArgumentList")++ * N("CloseParens")
                    ) as ConstructorInitializerThis;
                }
            }
            public static ConstructorInitializerThis of(ArgumentList _argumentlist)
            {
                return ConstructorInitializerThis.Instance.AcceptClause(0,Colon.Instance,This.Instance,OpenParens.Instance,_argumentlist,CloseParens.Instance)as ConstructorInitializerThis;
            }
        }

        public class DestructorDeclaration:CSharpDefinition
        {
            public static DestructorDeclaration Instance
            {
                get
                {
                    return new DestructorDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("Tilde") * N("Identifier") * N("OpenParens") * N("CloseParens") * N("Block")
                    ) as DestructorDeclaration;
                }
            }
            public static DestructorDeclaration of(AttributeSection _attributesection,Identifier _identifier,Block _block)
            {
                return DestructorDeclaration.Instance.AcceptClause(0,_attributesection,Tilde.Instance,_identifier,OpenParens.Instance,CloseParens.Instance,_block)as DestructorDeclaration;
            }
        }

        public class EventDeclaration:CSharpDefinition
        {
            public static EventDeclaration Instance
            {
                get
                {
                    return new EventDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Event") * N("Type") * N("VariableDeclarators") * N("Semicolon")
                        +
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Event") * N("Type") * N("MemberName") * N("OpenBrace") * N("EventAccessorDeclarations") * N("CloseBrace")
                    ) as EventDeclaration;
                }
            }
            public static EventDeclaration of(AttributeSection _attributesection,Modifier _modifier,Type _type,VariableDeclarators _variabledeclarators)
            {
                return EventDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,Event.Instance,_type,_variabledeclarators,Semicolon.Instance)as EventDeclaration;
            }
            public static EventDeclaration of(AttributeSection _attributesection,Modifier _modifier,Type _type,MemberName _membername,EventAccessorDeclarations _eventaccessordeclarations)
            {
                return EventDeclaration.Instance.AcceptClause(1,_attributesection,_modifier,Event.Instance,_type,_membername,OpenBrace.Instance,_eventaccessordeclarations,CloseBrace.Instance)as EventDeclaration;
            }
        }

        public class EventAccessorDeclarations:CSharpDefinition
        {
            public static EventAccessorDeclarations Instance
            {
                get
                {
                    return new EventAccessorDeclarations().DefineAs(
                        N("AddAccessorDeclaration") * N("RemoveAccessorDeclaration")
                        +
                        N("RemoveAccessorDeclaration") * N("AddAccessorDeclaration")
                    ) as EventAccessorDeclarations;
                }
            }
            public static EventAccessorDeclarations of(AddAccessorDeclaration _addaccessordeclaration,RemoveAccessorDeclaration _removeaccessordeclaration)
            {
                return EventAccessorDeclarations.Instance.AcceptClause(0,_addaccessordeclaration,_removeaccessordeclaration)as EventAccessorDeclarations;
            }
            public static EventAccessorDeclarations of(RemoveAccessorDeclaration _removeaccessordeclaration,AddAccessorDeclaration _addaccessordeclaration)
            {
                return EventAccessorDeclarations.Instance.AcceptClause(1,_removeaccessordeclaration,_addaccessordeclaration)as EventAccessorDeclarations;
            }
        }

        public class AddAccessorDeclaration:CSharpDefinition
        {
            public static AddAccessorDeclaration Instance
            {
                get
                {
                    return new AddAccessorDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("Add") * N("Block")
                    ) as AddAccessorDeclaration;
                }
            }
            public static AddAccessorDeclaration of(AttributeSection _attributesection,Block _block)
            {
                return AddAccessorDeclaration.Instance.AcceptClause(0,_attributesection,Add.Instance,_block)as AddAccessorDeclaration;
            }
        }

        public class RemoveAccessorDeclaration:CSharpDefinition
        {
            public static RemoveAccessorDeclaration Instance
            {
                get
                {
                    return new RemoveAccessorDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("Remove") * N("Block")
                    ) as RemoveAccessorDeclaration;
                }
            }
            public static RemoveAccessorDeclaration of(AttributeSection _attributesection,Block _block)
            {
                return RemoveAccessorDeclaration.Instance.AcceptClause(0,_attributesection,Remove.Instance,_block)as RemoveAccessorDeclaration;
            }
        }

        public class IndexerDeclaration:CSharpDefinition
        {
            public static IndexerDeclaration Instance
            {
                get
                {
                    return new IndexerDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("IndexerDeclarator") * N("OpenBrace") * N("CloseBrace")
                    ) as IndexerDeclaration;
                }
            }
            public static IndexerDeclaration of(AttributeSection _attributesection,Modifier _modifier,IndexerDeclarator _indexerdeclarator)
            {
                return IndexerDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,_indexerdeclarator,OpenBrace.Instance,CloseBrace.Instance)as IndexerDeclaration;
            }
        }

        public class IndexerDeclarator:CSharpDefinition
        {
            public static IndexerDeclarator Instance
            {
                get
                {
                    return new IndexerDeclarator().DefineAs(
                        N("Type") * N("This") * N("OpenBracket") * N("FormalParameterList")++ * N("CloseBracket")
                        +
                        N("Type") * N("QualifiedIdentifier") * N("Dot") * N("This") * N("OpenBracket") * N("FormalParameterList")++ * N("CloseBracket")
                    ) as IndexerDeclarator;
                }
            }
            public static IndexerDeclarator of(Type _type,FormalParameterList _formalparameterlist)
            {
                return IndexerDeclarator.Instance.AcceptClause(0,_type,This.Instance,OpenBracket.Instance,_formalparameterlist,CloseBracket.Instance)as IndexerDeclarator;
            }
            public static IndexerDeclarator of(Type _type,QualifiedIdentifier _qualifiedidentifier,FormalParameterList _formalparameterlist)
            {
                return IndexerDeclarator.Instance.AcceptClause(1,_type,_qualifiedidentifier,Dot.Instance,This.Instance,OpenBracket.Instance,_formalparameterlist,CloseBracket.Instance)as IndexerDeclarator;
            }
        }

        public class EnumDeclaration:CSharpDefinition
        {
            public static EnumDeclaration Instance
            {
                get
                {
                    return new EnumDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Enum") * N("Identifier") * N("EnumBase")++ * N("EnumBody") * N("Semicolon")++
                    ) as EnumDeclaration;
                }
            }
            public static EnumDeclaration of(AttributeSection _attributesection,Modifier _modifier,Identifier _identifier,EnumBase _enumbase,EnumBody _enumbody)
            {
                return EnumDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,Enum.Instance,_identifier,_enumbase,_enumbody,Semicolon.Instance)as EnumDeclaration;
            }
        }

        public class EnumBase:CSharpDefinition
        {
            public static EnumBase Instance
            {
                get
                {
                    return new EnumBase().DefineAs(
                        N("Colon") * N("Type")
                    ) as EnumBase;
                }
            }
            public static EnumBase of(Type _type)
            {
                return EnumBase.Instance.AcceptClause(0,Colon.Instance,_type)as EnumBase;
            }
        }

        public class EnumBody:CSharpDefinition
        {
            public static EnumBody Instance
            {
                get
                {
                    return new EnumBody().DefineAs(
                        N("OpenBrace") * N("EnumMemberDeclarations")++ * N("CloseBrace")
                    ) as EnumBody;
                }
            }
            public static EnumBody of(EnumMemberDeclarations _enummemberdeclarations)
            {
                return EnumBody.Instance.AcceptClause(0,OpenBrace.Instance,_enummemberdeclarations,CloseBrace.Instance)as EnumBody;
            }
        }

        public class EnumMemberDeclarations:CSharpDefinition
        {
            public static EnumMemberDeclarations Instance
            {
                get
                {
                    return new EnumMemberDeclarations().DefineAs(
                        N("EnumMemberDeclaration")
                        +
                        N("EnumMemberDeclarations") * N("Comma") * N("EnumMemberDeclaration")
                    ) as EnumMemberDeclarations;
                }
            }
            public static EnumMemberDeclarations of(EnumMemberDeclaration _enummemberdeclaration)
            {
                return EnumMemberDeclarations.Instance.AcceptClause(0,_enummemberdeclaration)as EnumMemberDeclarations;
            }
            public static EnumMemberDeclarations of(EnumMemberDeclarations _enummemberdeclarations,EnumMemberDeclaration _enummemberdeclaration)
            {
                return EnumMemberDeclarations.Instance.AcceptClause(1,_enummemberdeclarations,Comma.Instance,_enummemberdeclaration)as EnumMemberDeclarations;
            }
        }

        public class EnumMemberDeclaration:CSharpDefinition
        {
            public static EnumMemberDeclaration Instance
            {
                get
                {
                    return new EnumMemberDeclaration().DefineAs(
                        ~N("AttributeSection")++ * N("Identifier")
                        +
                        ~N("AttributeSection")++ * N("Identifier") * N("Assign") * N("Expression")
                    ) as EnumMemberDeclaration;
                }
            }
            public static EnumMemberDeclaration of(AttributeSection _attributesection,Identifier _identifier)
            {
                return EnumMemberDeclaration.Instance.AcceptClause(0,_attributesection,_identifier)as EnumMemberDeclaration;
            }
            public static EnumMemberDeclaration of(AttributeSection _attributesection,Identifier _identifier,Expression _expression)
            {
                return EnumMemberDeclaration.Instance.AcceptClause(1,_attributesection,_identifier,Assign.Instance,_expression)as EnumMemberDeclaration;
            }
        }

        public class DelegateDeclaration:CSharpDefinition
        {
            public static DelegateDeclaration Instance
            {
                get
                {
                    return new DelegateDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Delegate") * N("Type") * N("Identifier") * N("OpenParens") * N("FormalParameterList")++ * N("CloseParens") * N("Semicolon")
                        +
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Delegate") * N("Void") * N("Identifier") * N("OpenParens") * N("FormalParameterList")++ * N("CloseParens") * N("Semicolon")
                    ) as DelegateDeclaration;
                }
            }
            public static DelegateDeclaration of(AttributeSection _attributesection,Modifier _modifier,Type _type,Identifier _identifier,FormalParameterList _formalparameterlist)
            {
                return DelegateDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,Delegate.Instance,_type,_identifier,OpenParens.Instance,_formalparameterlist,CloseParens.Instance,Semicolon.Instance)as DelegateDeclaration;
            }
            public static DelegateDeclaration of(AttributeSection _attributesection,Modifier _modifier,Identifier _identifier,FormalParameterList _formalparameterlist)
            {
                return DelegateDeclaration.Instance.AcceptClause(1,_attributesection,_modifier,Delegate.Instance,Void.Instance,_identifier,OpenParens.Instance,_formalparameterlist,CloseParens.Instance,Semicolon.Instance)as DelegateDeclaration;
            }
        }

        public class Type:CSharpDefinition
        {
            public static Type Instance
            {
                get
                {
                    return new Type().DefineAs(
                        N("QualifiedIdentifier")
                        +
                        N("BuiltinTypes")
                        +
                        N("ArrayType")
                        +
                        N("PointerType")
                    ) as Type;
                }
            }
            public static Type of(QualifiedIdentifier _qualifiedidentifier)
            {
                return Type.Instance.AcceptClause(0,_qualifiedidentifier)as Type;
            }
            public static Type of(BuiltinTypes _builtintypes)
            {
                return Type.Instance.AcceptClause(1,_builtintypes)as Type;
            }
            public static Type of(ArrayType _arraytype)
            {
                return Type.Instance.AcceptClause(2,_arraytype)as Type;
            }
            public static Type of(PointerType _pointertype)
            {
                return Type.Instance.AcceptClause(3,_pointertype)as Type;
            }
        }

        public class NamespaceOrTypeName:CSharpDefinition
        {
            public static NamespaceOrTypeName Instance
            {
                get
                {
                    return new NamespaceOrTypeName().DefineAs(
                        N("Identifier")
                        +
                        N("NamespaceOrTypeName") * N("Dot") * N("Identifier")
                    ) as NamespaceOrTypeName;
                }
            }
            public static NamespaceOrTypeName of(Identifier _identifier)
            {
                return NamespaceOrTypeName.Instance.AcceptClause(0,_identifier)as NamespaceOrTypeName;
            }
            public static NamespaceOrTypeName of(NamespaceOrTypeName _namespaceortypename,Identifier _identifier)
            {
                return NamespaceOrTypeName.Instance.AcceptClause(1,_namespaceortypename,Dot.Instance,_identifier)as NamespaceOrTypeName;
            }
        }

        public class PointerType:CSharpDefinition
        {
            public static PointerType Instance
            {
                get
                {
                    return new PointerType().DefineAs(
                        N("Type") * N("Star")
                        +
                        N("Void") * N("Star")
                    ) as PointerType;
                }
            }
            public static PointerType of(Type _type)
            {
                return PointerType.Instance.AcceptClause(0,_type,Star.Instance)as PointerType;
            }
        }

        public class NonExpressionType:CSharpDefinition
        {
            public static NonExpressionType Instance
            {
                get
                {
                    return new NonExpressionType().DefineAs(
                        N("BuiltinTypes")
                        +
                        N("NonExpressionType") * N("RankSpecifier")
                        +
                        N("NonExpressionType") * N("Star")
                        +
                        N("Expression") * ~N("RankSpecifier")
                        +
                        N("Expression") * N("Star")
                    ) as NonExpressionType;
                }
            }
            public static NonExpressionType of(BuiltinTypes _builtintypes)
            {
                return NonExpressionType.Instance.AcceptClause(0,_builtintypes)as NonExpressionType;
            }
            public static NonExpressionType of(NonExpressionType _nonexpressiontype,RankSpecifier _rankspecifier)
            {
                return NonExpressionType.Instance.AcceptClause(1,_nonexpressiontype,_rankspecifier)as NonExpressionType;
            }
            public static NonExpressionType of(NonExpressionType _nonexpressiontype)
            {
                return NonExpressionType.Instance.AcceptClause(2,_nonexpressiontype,Star.Instance)as NonExpressionType;
            }
            public static NonExpressionType of(Expression _expression,RankSpecifier _rankspecifier)
            {
                return NonExpressionType.Instance.AcceptClause(3,_expression,_rankspecifier)as NonExpressionType;
            }
            public static NonExpressionType of(Expression _expression)
            {
                return NonExpressionType.Instance.AcceptClause(4,_expression,Star.Instance)as NonExpressionType;
            }
        }

        public class TypeList:CSharpDefinition
        {
            public static TypeList Instance
            {
                get
                {
                    return new TypeList().DefineAs(
                        N("Type")
                        +
                        N("TypeList") * N("Comma") * N("Type")
                    ) as TypeList;
                }
            }
            public static TypeList of(Type _type)
            {
                return TypeList.Instance.AcceptClause(0,_type)as TypeList;
            }
            public static TypeList of(TypeList _typelist,Type _type)
            {
                return TypeList.Instance.AcceptClause(1,_typelist,Comma.Instance,_type)as TypeList;
            }
        }

        public class BuiltinTypes:CSharpDefinition
        {
            public static BuiltinTypes Instance
            {
                get
                {
                    return new BuiltinTypes().DefineAs(
                        N("Object")
                        +
                        N("String")
                        +
                        N("Bool")
                        +
                        N("Decimal")
                        +
                        N("Float")
                        +
                        N("Double")
                        +
                        N("IntegralType")
                    ) as BuiltinTypes;
                }
            }
            public static BuiltinTypes of(Object _object)
            {
                return BuiltinTypes.Instance.AcceptClause(0,_object)as BuiltinTypes;
            }
            public static BuiltinTypes of(String _string)
            {
                return BuiltinTypes.Instance.AcceptClause(1,_string)as BuiltinTypes;
            }
            public static BuiltinTypes of(Bool _bool)
            {
                return BuiltinTypes.Instance.AcceptClause(2,_bool)as BuiltinTypes;
            }
            public static BuiltinTypes of(Decimal _decimal)
            {
                return BuiltinTypes.Instance.AcceptClause(3,_decimal)as BuiltinTypes;
            }
            public static BuiltinTypes of(Float _float)
            {
                return BuiltinTypes.Instance.AcceptClause(4,_float)as BuiltinTypes;
            }
            public static BuiltinTypes of(Double _double)
            {
                return BuiltinTypes.Instance.AcceptClause(5,_double)as BuiltinTypes;
            }
            public static BuiltinTypes of(IntegralType _integraltype)
            {
                return BuiltinTypes.Instance.AcceptClause(6,_integraltype)as BuiltinTypes;
            }
        }

        public class IntegralType:CSharpDefinition
        {
            public static IntegralType Instance
            {
                get
                {
                    return new IntegralType().DefineAs(
                        N("Sbyte")
                        +
                        N("Byte")
                        +
                        N("Short")
                        +
                        N("Ushort")
                        +
                        N("Int")
                        +
                        N("Uint")
                        +
                        N("Long")
                        +
                        N("Ulong")
                        +
                        N("Char")
                    ) as IntegralType;
                }
            }
            public static IntegralType of(Sbyte _sbyte)
            {
                return IntegralType.Instance.AcceptClause(0,_sbyte)as IntegralType;
            }
            public static IntegralType of(Byte _byte)
            {
                return IntegralType.Instance.AcceptClause(1,_byte)as IntegralType;
            }
            public static IntegralType of(Short _short)
            {
                return IntegralType.Instance.AcceptClause(2,_short)as IntegralType;
            }
            public static IntegralType of(Ushort _ushort)
            {
                return IntegralType.Instance.AcceptClause(3,_ushort)as IntegralType;
            }
            public static IntegralType of(Int _int)
            {
                return IntegralType.Instance.AcceptClause(4,_int)as IntegralType;
            }
            public static IntegralType of(Uint _uint)
            {
                return IntegralType.Instance.AcceptClause(5,_uint)as IntegralType;
            }
            public static IntegralType of(Long _long)
            {
                return IntegralType.Instance.AcceptClause(6,_long)as IntegralType;
            }
            public static IntegralType of(Ulong _ulong)
            {
                return IntegralType.Instance.AcceptClause(7,_ulong)as IntegralType;
            }
            public static IntegralType of(Char _char)
            {
                return IntegralType.Instance.AcceptClause(8,_char)as IntegralType;
            }
        }

        public class InterfaceType:CSharpDefinition
        {
            public static InterfaceType Instance
            {
                get
                {
                    return new InterfaceType().DefineAs(
                        N("QualifiedIdentifier")
                    ) as InterfaceType;
                }
            }
            public static InterfaceType of(QualifiedIdentifier _qualifiedidentifier)
            {
                return InterfaceType.Instance.AcceptClause(0,_qualifiedidentifier)as InterfaceType;
            }
        }

        public class ArrayType:CSharpDefinition
        {
            public static ArrayType Instance
            {
                get
                {
                    return new ArrayType().DefineAs(
                        N("Type") * ~N("RankSpecifier")
                    ) as ArrayType;
                }
            }
            public static ArrayType of(Type _type,RankSpecifier _rankspecifier)
            {
                return ArrayType.Instance.AcceptClause(0,_type,_rankspecifier)as ArrayType;
            }
        }

        public class PrimaryExpression:CSharpDefinition
        {
            public static PrimaryExpression Instance
            {
                get
                {
                    return new PrimaryExpression().DefineAs(
                        N("Literal")
                        +
                        N("QualifiedIdentifier")
                        +
                        N("ParenthesizedExpression")
                        +
                        N("MemberAccess")
                        +
                        N("InvocationExpression")
                        +
                        N("ElementAccess")
                        +
                        N("ThisAccess")
                        +
                        N("BaseAccess")
                        +
                        N("PostIncrementExpression")
                        +
                        N("PostDecrementExpression")
                        +
                        N("NewExpression")
                        +
                        N("TypeofExpression")
                        +
                        N("SizeofExpression")
                        +
                        N("CheckedExpression")
                        +
                        N("UncheckedExpression")
                        +
                        N("PointerMemberAccess")
                    ) as PrimaryExpression;
                }
            }
            public static PrimaryExpression of(Literal _literal)
            {
                return PrimaryExpression.Instance.AcceptClause(0,_literal)as PrimaryExpression;
            }
            public static PrimaryExpression of(QualifiedIdentifier _qualifiedidentifier)
            {
                return PrimaryExpression.Instance.AcceptClause(1,_qualifiedidentifier)as PrimaryExpression;
            }
            public static PrimaryExpression of(ParenthesizedExpression _parenthesizedexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(2,_parenthesizedexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(MemberAccess _memberaccess)
            {
                return PrimaryExpression.Instance.AcceptClause(3,_memberaccess)as PrimaryExpression;
            }
            public static PrimaryExpression of(InvocationExpression _invocationexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(4,_invocationexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(ElementAccess _elementaccess)
            {
                return PrimaryExpression.Instance.AcceptClause(5,_elementaccess)as PrimaryExpression;
            }
            public static PrimaryExpression of(ThisAccess _thisaccess)
            {
                return PrimaryExpression.Instance.AcceptClause(6,_thisaccess)as PrimaryExpression;
            }
            public static PrimaryExpression of(BaseAccess _baseaccess)
            {
                return PrimaryExpression.Instance.AcceptClause(7,_baseaccess)as PrimaryExpression;
            }
            public static PrimaryExpression of(PostIncrementExpression _postincrementexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(8,_postincrementexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(PostDecrementExpression _postdecrementexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(9,_postdecrementexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(NewExpression _newexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(10,_newexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(TypeofExpression _typeofexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(11,_typeofexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(SizeofExpression _sizeofexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(12,_sizeofexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(CheckedExpression _checkedexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(13,_checkedexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(UncheckedExpression _uncheckedexpression)
            {
                return PrimaryExpression.Instance.AcceptClause(14,_uncheckedexpression)as PrimaryExpression;
            }
            public static PrimaryExpression of(PointerMemberAccess _pointermemberaccess)
            {
                return PrimaryExpression.Instance.AcceptClause(15,_pointermemberaccess)as PrimaryExpression;
            }
        }

        public class Literal:CSharpDefinition
        {
            public static Literal Instance
            {
                get
                {
                    return new Literal().DefineAs(
                        N("BooleanLiteral")
                        +
                        N("IntegerLiteral")
                        +
                        N("RealLiteral")
                        +
                        N("LiteralCharacter")
                        +
                        N("LiteralString")
                        +
                        N("Null")
                    ) as Literal;
                }
            }
            public static Literal of(BooleanLiteral _booleanliteral)
            {
                return Literal.Instance.AcceptClause(0,_booleanliteral)as Literal;
            }
            public static Literal of(IntegerLiteral _integerliteral)
            {
                return Literal.Instance.AcceptClause(1,_integerliteral)as Literal;
            }
            public static Literal of(RealLiteral _realliteral)
            {
                return Literal.Instance.AcceptClause(2,_realliteral)as Literal;
            }
            public static Literal of(LiteralCharacter _literalcharacter)
            {
                return Literal.Instance.AcceptClause(3,_literalcharacter)as Literal;
            }
            public static Literal of(LiteralString _literalstring)
            {
                return Literal.Instance.AcceptClause(4,_literalstring)as Literal;
            }
            public static Literal of(Null _null)
            {
                return Literal.Instance.AcceptClause(5,_null)as Literal;
            }
        }

        public class RealLiteral:CSharpDefinition
        {
            public static RealLiteral Instance
            {
                get
                {
                    return new RealLiteral().DefineAs(
                        N("LiteralFloat")
                        +
                        N("LiteralDouble")
                        +
                        N("LiteralDecimal")
                    ) as RealLiteral;
                }
            }
            public static RealLiteral of(LiteralFloat _literalfloat)
            {
                return RealLiteral.Instance.AcceptClause(0,_literalfloat)as RealLiteral;
            }
            public static RealLiteral of(LiteralDouble _literaldouble)
            {
                return RealLiteral.Instance.AcceptClause(1,_literaldouble)as RealLiteral;
            }
            public static RealLiteral of(LiteralDecimal _literaldecimal)
            {
                return RealLiteral.Instance.AcceptClause(2,_literaldecimal)as RealLiteral;
            }
        }

        public class IntegerLiteral:CSharpDefinition
        {
            public static IntegerLiteral Instance
            {
                get
                {
                    return new IntegerLiteral().DefineAs(
                        N("LiteralInteger")
                    ) as IntegerLiteral;
                }
            }
            public static IntegerLiteral of(LiteralInteger _literalinteger)
            {
                return IntegerLiteral.Instance.AcceptClause(0,_literalinteger)as IntegerLiteral;
            }
        }

        public class BooleanLiteral:CSharpDefinition
        {
            public static BooleanLiteral Instance
            {
                get
                {
                    return new BooleanLiteral().DefineAs(
                        N("True")
                        +
                        N("False")
                    ) as BooleanLiteral;
                }
            }
            public static BooleanLiteral of(True _true)
            {
                return BooleanLiteral.Instance.AcceptClause(0,_true)as BooleanLiteral;
            }
            public static BooleanLiteral of(False _false)
            {
                return BooleanLiteral.Instance.AcceptClause(1,_false)as BooleanLiteral;
            }
        }

        public class ParenthesizedExpression:CSharpDefinition
        {
            public static ParenthesizedExpression Instance
            {
                get
                {
                    return new ParenthesizedExpression().DefineAs(
                        N("OpenParens") * N("Expression") * N("CloseParens")
                    ) as ParenthesizedExpression;
                }
            }
            public static ParenthesizedExpression of(Expression _expression)
            {
                return ParenthesizedExpression.Instance.AcceptClause(0,OpenParens.Instance,_expression,CloseParens.Instance)as ParenthesizedExpression;
            }
        }

        public class MemberAccess:CSharpDefinition
        {
            public static MemberAccess Instance
            {
                get
                {
                    return new MemberAccess().DefineAs(
                        N("PrimaryExpression") * N("Dot") * N("Identifier")
                        +
                        N("PredefinedType") * N("Dot") * N("Identifier")
                    ) as MemberAccess;
                }
            }
            public static MemberAccess of(PrimaryExpression _primaryexpression,Identifier _identifier)
            {
                return MemberAccess.Instance.AcceptClause(0,_primaryexpression,Dot.Instance,_identifier)as MemberAccess;
            }
            public static MemberAccess of(PredefinedType _predefinedtype,Identifier _identifier)
            {
                return MemberAccess.Instance.AcceptClause(1,_predefinedtype,Dot.Instance,_identifier)as MemberAccess;
            }
        }

        public class PredefinedType:CSharpDefinition
        {
            public static PredefinedType Instance
            {
                get
                {
                    return new PredefinedType().DefineAs(
                        N("BuiltinTypes")
                    ) as PredefinedType;
                }
            }
            public static PredefinedType of(BuiltinTypes _builtintypes)
            {
                return PredefinedType.Instance.AcceptClause(0,_builtintypes)as PredefinedType;
            }
        }

        public class InvocationExpression:CSharpDefinition
        {
            public static InvocationExpression Instance
            {
                get
                {
                    return new InvocationExpression().DefineAs(
                        N("PrimaryExpression") * N("OpenParens") * N("ArgumentList")++ * N("CloseParens")
                    ) as InvocationExpression;
                }
            }
            public static InvocationExpression of(PrimaryExpression _primaryexpression,ArgumentList _argumentlist)
            {
                return InvocationExpression.Instance.AcceptClause(0,_primaryexpression,OpenParens.Instance,_argumentlist,CloseParens.Instance)as InvocationExpression;
            }
        }

        public class ArgumentList:CSharpDefinition
        {
            public static ArgumentList Instance
            {
                get
                {
                    return new ArgumentList().DefineAs(
                        N("Argument")
                        +
                        N("ArgumentList") * N("Comma") * N("Argument")
                    ) as ArgumentList;
                }
            }
            public static ArgumentList of(Argument _argument)
            {
                return ArgumentList.Instance.AcceptClause(0,_argument)as ArgumentList;
            }
            public static ArgumentList of(ArgumentList _argumentlist,Argument _argument)
            {
                return ArgumentList.Instance.AcceptClause(1,_argumentlist,Comma.Instance,_argument)as ArgumentList;
            }
        }

        public class Argument:CSharpDefinition
        {
            public static Argument Instance
            {
                get
                {
                    return new Argument().DefineAs(
                        N("Expression")
                        +
                        N("ArgumentRef")
                        +
                        N("ArgumentOut")
                    ) as Argument;
                }
            }
            public static Argument of(Expression _expression)
            {
                return Argument.Instance.AcceptClause(0,_expression)as Argument;
            }
            public static Argument of(ArgumentRef _argumentref)
            {
                return Argument.Instance.AcceptClause(1,_argumentref)as Argument;
            }
            public static Argument of(ArgumentOut _argumentout)
            {
                return Argument.Instance.AcceptClause(2,_argumentout)as Argument;
            }
        }

        public class ArgumentRef:CSharpDefinition
        {
            public static ArgumentRef Instance
            {
                get
                {
                    return new ArgumentRef().DefineAs(
                        N("Ref") * N("VariableReference")
                    ) as ArgumentRef;
                }
            }
            public static ArgumentRef of(VariableReference _variablereference)
            {
                return ArgumentRef.Instance.AcceptClause(0,Ref.Instance,_variablereference)as ArgumentRef;
            }
        }

        public class ArgumentOut:CSharpDefinition
        {
            public static ArgumentOut Instance
            {
                get
                {
                    return new ArgumentOut().DefineAs(
                        N("Out") * N("VariableReference")
                    ) as ArgumentOut;
                }
            }
            public static ArgumentOut of(VariableReference _variablereference)
            {
                return ArgumentOut.Instance.AcceptClause(0,Out.Instance,_variablereference)as ArgumentOut;
            }
        }

        public class VariableReference:CSharpDefinition
        {
            public static VariableReference Instance
            {
                get
                {
                    return new VariableReference().DefineAs(
                        N("Expression")
                    ) as VariableReference;
                }
            }
            public static VariableReference of(Expression _expression)
            {
                return VariableReference.Instance.AcceptClause(0,_expression)as VariableReference;
            }
        }

        public class ElementAccess:CSharpDefinition
        {
            public static ElementAccess Instance
            {
                get
                {
                    return new ElementAccess().DefineAs(
                        N("PrimaryExpression") * N("OpenBracket") * N("ExpressionList") * N("CloseBracket")
                        +
                        N("PrimaryExpression") * ~N("RankSpecifier")
                    ) as ElementAccess;
                }
            }
            public static ElementAccess of(PrimaryExpression _primaryexpression,ExpressionList _expressionlist)
            {
                return ElementAccess.Instance.AcceptClause(0,_primaryexpression,OpenBracket.Instance,_expressionlist,CloseBracket.Instance)as ElementAccess;
            }
            public static ElementAccess of(PrimaryExpression _primaryexpression,RankSpecifier _rankspecifier)
            {
                return ElementAccess.Instance.AcceptClause(1,_primaryexpression,_rankspecifier)as ElementAccess;
            }
        }

        public class ExpressionList:CSharpDefinition
        {
            public static ExpressionList Instance
            {
                get
                {
                    return new ExpressionList().DefineAs(
                        N("Expression")
                        +
                        N("ExpressionList") * N("Comma") * N("Expression")
                    ) as ExpressionList;
                }
            }
            public static ExpressionList of(Expression _expression)
            {
                return ExpressionList.Instance.AcceptClause(0,_expression)as ExpressionList;
            }
            public static ExpressionList of(ExpressionList _expressionlist,Expression _expression)
            {
                return ExpressionList.Instance.AcceptClause(1,_expressionlist,Comma.Instance,_expression)as ExpressionList;
            }
        }

        public class ThisAccess:CSharpDefinition
        {
            public static ThisAccess Instance
            {
                get
                {
                    return new ThisAccess().DefineAs(
                        N("This")
                    ) as ThisAccess;
                }
            }
            public static ThisAccess of(This _this)
            {
                return ThisAccess.Instance.AcceptClause(0,_this)as ThisAccess;
            }
        }

        public class BaseAccess:CSharpDefinition
        {
            public static BaseAccess Instance
            {
                get
                {
                    return new BaseAccess().DefineAs(
                        N("Base") * N("Dot") * N("Identifier")
                        +
                        N("Base") * N("OpenBracket") * N("ExpressionList") * N("CloseBracket")
                    ) as BaseAccess;
                }
            }
            public static BaseAccess of(Identifier _identifier)
            {
                return BaseAccess.Instance.AcceptClause(0,Base.Instance,Dot.Instance,_identifier)as BaseAccess;
            }
            public static BaseAccess of(ExpressionList _expressionlist)
            {
                return BaseAccess.Instance.AcceptClause(1,Base.Instance,OpenBracket.Instance,_expressionlist,CloseBracket.Instance)as BaseAccess;
            }
        }

        public class PostIncrementExpression:CSharpDefinition
        {
            public static PostIncrementExpression Instance
            {
                get
                {
                    return new PostIncrementExpression().DefineAs(
                        N("PrimaryExpression") * N("OpInc")
                    ) as PostIncrementExpression;
                }
            }
            public static PostIncrementExpression of(PrimaryExpression _primaryexpression)
            {
                return PostIncrementExpression.Instance.AcceptClause(0,_primaryexpression,OpInc.Instance)as PostIncrementExpression;
            }
        }

        public class PostDecrementExpression:CSharpDefinition
        {
            public static PostDecrementExpression Instance
            {
                get
                {
                    return new PostDecrementExpression().DefineAs(
                        N("PrimaryExpression") * N("OpDec")
                    ) as PostDecrementExpression;
                }
            }
            public static PostDecrementExpression of(PrimaryExpression _primaryexpression)
            {
                return PostDecrementExpression.Instance.AcceptClause(0,_primaryexpression,OpDec.Instance)as PostDecrementExpression;
            }
        }

        public class NewExpression:CSharpDefinition
        {
            public static NewExpression Instance
            {
                get
                {
                    return new NewExpression().DefineAs(
                        N("ObjectOrDelegateCreationExpression")
                        +
                        N("ArrayCreationExpression")
                    ) as NewExpression;
                }
            }
            public static NewExpression of(ObjectOrDelegateCreationExpression _objectordelegatecreationexpression)
            {
                return NewExpression.Instance.AcceptClause(0,_objectordelegatecreationexpression)as NewExpression;
            }
            public static NewExpression of(ArrayCreationExpression _arraycreationexpression)
            {
                return NewExpression.Instance.AcceptClause(1,_arraycreationexpression)as NewExpression;
            }
        }

        public class ObjectOrDelegateCreationExpression:CSharpDefinition
        {
            public static ObjectOrDelegateCreationExpression Instance
            {
                get
                {
                    return new ObjectOrDelegateCreationExpression().DefineAs(
                        N("New") * N("Type") * N("OpenParens") * N("ArgumentList")++ * N("CloseParens")
                    ) as ObjectOrDelegateCreationExpression;
                }
            }
            public static ObjectOrDelegateCreationExpression of(Type _type,ArgumentList _argumentlist)
            {
                return ObjectOrDelegateCreationExpression.Instance.AcceptClause(0,New.Instance,_type,OpenParens.Instance,_argumentlist,CloseParens.Instance)as ObjectOrDelegateCreationExpression;
            }
        }

        public class ArrayCreationExpression:CSharpDefinition
        {
            public static ArrayCreationExpression Instance
            {
                get
                {
                    return new ArrayCreationExpression().DefineAs(
                        N("New") * N("Type") * N("OpenBracket") * N("ExpressionList") * N("CloseBracket") * ~N("RankSpecifier")++ * N("ArrayInitializer")++
                        +
                        N("New") * N("Type") * ~N("RankSpecifier") * N("ArrayInitializer")
                        +
                        N("New") * N("Type") * N("Error")
                    ) as ArrayCreationExpression;
                }
            }
            public static ArrayCreationExpression of(Type _type,ExpressionList _expressionlist,RankSpecifier _rankspecifier,ArrayInitializer _arrayinitializer)
            {
                return ArrayCreationExpression.Instance.AcceptClause(0,New.Instance,_type,OpenBracket.Instance,_expressionlist,CloseBracket.Instance,_rankspecifier,_arrayinitializer)as ArrayCreationExpression;
            }
            public static ArrayCreationExpression of(Type _type,RankSpecifier _rankspecifier,ArrayInitializer _arrayinitializer)
            {
                return ArrayCreationExpression.Instance.AcceptClause(1,New.Instance,_type,_rankspecifier,_arrayinitializer)as ArrayCreationExpression;
            }
            public static ArrayCreationExpression of(Type _type,Error _error)
            {
                return ArrayCreationExpression.Instance.AcceptClause(2,New.Instance,_type,_error)as ArrayCreationExpression;
            }
        }

        public class RankSpecifier:CSharpDefinition
        {
            public static RankSpecifier Instance
            {
                get
                {
                    return new RankSpecifier().DefineAs(
                        N("OpenBracket") * ~N("DimSeparator")++ * N("CloseBracket")
                    ) as RankSpecifier;
                }
            }
            public static RankSpecifier of(DimSeparator _dimseparator)
            {
                return RankSpecifier.Instance.AcceptClause(0,OpenBracket.Instance,_dimseparator,CloseBracket.Instance)as RankSpecifier;
            }
        }

        public class DimSeparator:CSharpDefinition
        {
            public static DimSeparator Instance
            {
                get
                {
                    return new DimSeparator().DefineAs(
                        N("Comma")
                    ) as DimSeparator;
                }
            }
            public static DimSeparator of(Comma _comma)
            {
                return DimSeparator.Instance.AcceptClause(0,_comma)as DimSeparator;
            }
        }

        public class ArrayInitializer:CSharpDefinition
        {
            public static ArrayInitializer Instance
            {
                get
                {
                    return new ArrayInitializer().DefineAs(
                        N("OpenBrace") * N("CloseBrace")
                        +
                        N("OpenBrace") * N("VariableInitializerList") * N("Comma")++ * N("CloseBrace")
                    ) as ArrayInitializer;
                }
            }
            public static ArrayInitializer of(VariableInitializerList _variableinitializerlist)
            {
                return ArrayInitializer.Instance.AcceptClause(1,OpenBrace.Instance,_variableinitializerlist,Comma.Instance,CloseBrace.Instance)as ArrayInitializer;
            }
        }

        public class VariableInitializerList:CSharpDefinition
        {
            public static VariableInitializerList Instance
            {
                get
                {
                    return new VariableInitializerList().DefineAs(
                        N("VariableInitializer")
                        +
                        N("VariableInitializerList") * N("Comma") * N("VariableInitializer")
                    ) as VariableInitializerList;
                }
            }
            public static VariableInitializerList of(VariableInitializer _variableinitializer)
            {
                return VariableInitializerList.Instance.AcceptClause(0,_variableinitializer)as VariableInitializerList;
            }
            public static VariableInitializerList of(VariableInitializerList _variableinitializerlist,VariableInitializer _variableinitializer)
            {
                return VariableInitializerList.Instance.AcceptClause(1,_variableinitializerlist,Comma.Instance,_variableinitializer)as VariableInitializerList;
            }
        }

        public class TypeofExpression:CSharpDefinition
        {
            public static TypeofExpression Instance
            {
                get
                {
                    return new TypeofExpression().DefineAs(
                        N("Typeof") * N("OpenParens") * N("Type") * N("CloseParens")
                    ) as TypeofExpression;
                }
            }
            public static TypeofExpression of(Type _type)
            {
                return TypeofExpression.Instance.AcceptClause(0,Typeof.Instance,OpenParens.Instance,_type,CloseParens.Instance)as TypeofExpression;
            }
        }

        public class SizeofExpression:CSharpDefinition
        {
            public static SizeofExpression Instance
            {
                get
                {
                    return new SizeofExpression().DefineAs(
                        N("Sizeof") * N("OpenParens") * N("Type") * N("CloseParens")
                    ) as SizeofExpression;
                }
            }
            public static SizeofExpression of(Type _type)
            {
                return SizeofExpression.Instance.AcceptClause(0,Sizeof.Instance,OpenParens.Instance,_type,CloseParens.Instance)as SizeofExpression;
            }
        }

        public class CheckedExpression:CSharpDefinition
        {
            public static CheckedExpression Instance
            {
                get
                {
                    return new CheckedExpression().DefineAs(
                        N("Checked") * N("OpenParens") * N("Expression") * N("CloseParens")
                    ) as CheckedExpression;
                }
            }
            public static CheckedExpression of(Expression _expression)
            {
                return CheckedExpression.Instance.AcceptClause(0,Checked.Instance,OpenParens.Instance,_expression,CloseParens.Instance)as CheckedExpression;
            }
        }

        public class UncheckedExpression:CSharpDefinition
        {
            public static UncheckedExpression Instance
            {
                get
                {
                    return new UncheckedExpression().DefineAs(
                        N("Unchecked") * N("OpenParens") * N("Expression") * N("CloseParens")
                    ) as UncheckedExpression;
                }
            }
            public static UncheckedExpression of(Expression _expression)
            {
                return UncheckedExpression.Instance.AcceptClause(0,Unchecked.Instance,OpenParens.Instance,_expression,CloseParens.Instance)as UncheckedExpression;
            }
        }

        public class PointerMemberAccess:CSharpDefinition
        {
            public static PointerMemberAccess Instance
            {
                get
                {
                    return new PointerMemberAccess().DefineAs(
                        N("PrimaryExpression") * N("OpPtr") * N("Identifier")
                    ) as PointerMemberAccess;
                }
            }
            public static PointerMemberAccess of(PrimaryExpression _primaryexpression,Identifier _identifier)
            {
                return PointerMemberAccess.Instance.AcceptClause(0,_primaryexpression,OpPtr.Instance,_identifier)as PointerMemberAccess;
            }
        }

        public class UnaryExpression:CSharpDefinition
        {
            public static UnaryExpression Instance
            {
                get
                {
                    return new UnaryExpression().DefineAs(
                        N("PrimaryExpression")
                        +
                        N("UnaryOperator") * N("PrefixedUnaryExpression")
                        +
                        N("OpenParens") * N("Expression") * N("CloseParens") * N("UnaryExpression")
                        +
                        N("OpenParens") * N("NonExpressionType") * N("CloseParens") * N("PrefixedUnaryExpression")
                    ) as UnaryExpression;
                }
            }
            public static UnaryExpression of(PrimaryExpression _primaryexpression)
            {
                return UnaryExpression.Instance.AcceptClause(0,_primaryexpression)as UnaryExpression;
            }
            public static UnaryExpression of(UnaryOperator _unaryoperator,PrefixedUnaryExpression _prefixedunaryexpression)
            {
                return UnaryExpression.Instance.AcceptClause(1,_unaryoperator,_prefixedunaryexpression)as UnaryExpression;
            }
            public static UnaryExpression of(Expression _expression,UnaryExpression _unaryexpression)
            {
                return UnaryExpression.Instance.AcceptClause(2,OpenParens.Instance,_expression,CloseParens.Instance,_unaryexpression)as UnaryExpression;
            }
            public static UnaryExpression of(NonExpressionType _nonexpressiontype,PrefixedUnaryExpression _prefixedunaryexpression)
            {
                return UnaryExpression.Instance.AcceptClause(3,OpenParens.Instance,_nonexpressiontype,CloseParens.Instance,_prefixedunaryexpression)as UnaryExpression;
            }
        }

        public class UnaryOperator:CSharpDefinition
        {
            public static UnaryOperator Instance
            {
                get
                {
                    return new UnaryOperator().DefineAs(
                        N("Bang")
                        +
                        N("Tilde")
                    ) as UnaryOperator;
                }
            }
            public static UnaryOperator of(Bang _bang)
            {
                return UnaryOperator.Instance.AcceptClause(0,_bang)as UnaryOperator;
            }
            public static UnaryOperator of(Tilde _tilde)
            {
                return UnaryOperator.Instance.AcceptClause(1,_tilde)as UnaryOperator;
            }
        }

        public class PrefixedUnaryExpression:CSharpDefinition
        {
            public static PrefixedUnaryExpression Instance
            {
                get
                {
                    return new PrefixedUnaryExpression().DefineAs(
                        N("UnaryExpression")
                        +
                        N("PrefixedUnaryOperator") * N("PrefixedUnaryExpression")
                    ) as PrefixedUnaryExpression;
                }
            }
            public static PrefixedUnaryExpression of(UnaryExpression _unaryexpression)
            {
                return PrefixedUnaryExpression.Instance.AcceptClause(0,_unaryexpression)as PrefixedUnaryExpression;
            }
            public static PrefixedUnaryExpression of(PrefixedUnaryOperator _prefixedunaryoperator,PrefixedUnaryExpression _prefixedunaryexpression)
            {
                return PrefixedUnaryExpression.Instance.AcceptClause(1,_prefixedunaryoperator,_prefixedunaryexpression)as PrefixedUnaryExpression;
            }
        }

        public class PrefixedUnaryOperator:CSharpDefinition
        {
            public static PrefixedUnaryOperator Instance
            {
                get
                {
                    return new PrefixedUnaryOperator().DefineAs(
                        N("Plus")
                        +
                        N("Minus")
                        +
                        N("OpInc")
                        +
                        N("OpDec")
                        +
                        N("Star")
                        +
                        N("BitwiseAnd")
                    ) as PrefixedUnaryOperator;
                }
            }
            public static PrefixedUnaryOperator of(Plus _plus)
            {
                return PrefixedUnaryOperator.Instance.AcceptClause(0,_plus)as PrefixedUnaryOperator;
            }
            public static PrefixedUnaryOperator of(Minus _minus)
            {
                return PrefixedUnaryOperator.Instance.AcceptClause(1,_minus)as PrefixedUnaryOperator;
            }
            public static PrefixedUnaryOperator of(OpInc _opinc)
            {
                return PrefixedUnaryOperator.Instance.AcceptClause(2,_opinc)as PrefixedUnaryOperator;
            }
            public static PrefixedUnaryOperator of(OpDec _opdec)
            {
                return PrefixedUnaryOperator.Instance.AcceptClause(3,_opdec)as PrefixedUnaryOperator;
            }
            public static PrefixedUnaryOperator of(Star _star)
            {
                return PrefixedUnaryOperator.Instance.AcceptClause(4,_star)as PrefixedUnaryOperator;
            }
            public static PrefixedUnaryOperator of(BitwiseAnd _bitwiseand)
            {
                return PrefixedUnaryOperator.Instance.AcceptClause(5,_bitwiseand)as PrefixedUnaryOperator;
            }
        }

        public class PreIncrementExpression:CSharpDefinition
        {
            public static PreIncrementExpression Instance
            {
                get
                {
                    return new PreIncrementExpression().DefineAs(
                        N("OpInc") * N("PrefixedUnaryExpression")
                    ) as PreIncrementExpression;
                }
            }
            public static PreIncrementExpression of(PrefixedUnaryExpression _prefixedunaryexpression)
            {
                return PreIncrementExpression.Instance.AcceptClause(0,OpInc.Instance,_prefixedunaryexpression)as PreIncrementExpression;
            }
        }

        public class PreDecrementExpression:CSharpDefinition
        {
            public static PreDecrementExpression Instance
            {
                get
                {
                    return new PreDecrementExpression().DefineAs(
                        N("OpDec") * N("PrefixedUnaryExpression")
                    ) as PreDecrementExpression;
                }
            }
            public static PreDecrementExpression of(PrefixedUnaryExpression _prefixedunaryexpression)
            {
                return PreDecrementExpression.Instance.AcceptClause(0,OpDec.Instance,_prefixedunaryexpression)as PreDecrementExpression;
            }
        }

        public class MultiplicativeExpression:CSharpDefinition
        {
            public static MultiplicativeExpression Instance
            {
                get
                {
                    return new MultiplicativeExpression().DefineAs(
                        N("PrefixedUnaryExpression")
                        +
                        N("MultiplicativeExpression") * N("MultiplicativeOperator") * N("PrefixedUnaryExpression")
                    ) as MultiplicativeExpression;
                }
            }
            public static MultiplicativeExpression of(PrefixedUnaryExpression _prefixedunaryexpression)
            {
                return MultiplicativeExpression.Instance.AcceptClause(0,_prefixedunaryexpression)as MultiplicativeExpression;
            }
            public static MultiplicativeExpression of(MultiplicativeExpression _multiplicativeexpression,MultiplicativeOperator _multiplicativeoperator,PrefixedUnaryExpression _prefixedunaryexpression)
            {
                return MultiplicativeExpression.Instance.AcceptClause(1,_multiplicativeexpression,_multiplicativeoperator,_prefixedunaryexpression)as MultiplicativeExpression;
            }
        }

        public class MultiplicativeOperator:CSharpDefinition
        {
            public static MultiplicativeOperator Instance
            {
                get
                {
                    return new MultiplicativeOperator().DefineAs(
                        N("Star")
                        +
                        N("Div")
                        +
                        N("Percent")
                    ) as MultiplicativeOperator;
                }
            }
            public static MultiplicativeOperator of(Star _star)
            {
                return MultiplicativeOperator.Instance.AcceptClause(0,_star)as MultiplicativeOperator;
            }
            public static MultiplicativeOperator of(Div _div)
            {
                return MultiplicativeOperator.Instance.AcceptClause(1,_div)as MultiplicativeOperator;
            }
            public static MultiplicativeOperator of(Percent _percent)
            {
                return MultiplicativeOperator.Instance.AcceptClause(2,_percent)as MultiplicativeOperator;
            }
        }

        public class AdditiveExpression:CSharpDefinition
        {
            public static AdditiveExpression Instance
            {
                get
                {
                    return new AdditiveExpression().DefineAs(
                        N("MultiplicativeExpression")
                        +
                        N("AdditiveExpression") * N("AdditiveOperator") * N("MultiplicativeExpression")
                    ) as AdditiveExpression;
                }
            }
            public static AdditiveExpression of(MultiplicativeExpression _multiplicativeexpression)
            {
                return AdditiveExpression.Instance.AcceptClause(0,_multiplicativeexpression)as AdditiveExpression;
            }
            public static AdditiveExpression of(AdditiveExpression _additiveexpression,AdditiveOperator _additiveoperator,MultiplicativeExpression _multiplicativeexpression)
            {
                return AdditiveExpression.Instance.AcceptClause(1,_additiveexpression,_additiveoperator,_multiplicativeexpression)as AdditiveExpression;
            }
        }

        public class AdditiveOperator:CSharpDefinition
        {
            public static AdditiveOperator Instance
            {
                get
                {
                    return new AdditiveOperator().DefineAs(
                        N("Plus")
                        +
                        N("Minus")
                    ) as AdditiveOperator;
                }
            }
            public static AdditiveOperator of(Plus _plus)
            {
                return AdditiveOperator.Instance.AcceptClause(0,_plus)as AdditiveOperator;
            }
            public static AdditiveOperator of(Minus _minus)
            {
                return AdditiveOperator.Instance.AcceptClause(1,_minus)as AdditiveOperator;
            }
        }

        public class ShiftExpression:CSharpDefinition
        {
            public static ShiftExpression Instance
            {
                get
                {
                    return new ShiftExpression().DefineAs(
                        N("AdditiveExpression")
                        +
                        N("ShiftExpression") * N("ShiftOperator") * N("AdditiveExpression")
                    ) as ShiftExpression;
                }
            }
            public static ShiftExpression of(AdditiveExpression _additiveexpression)
            {
                return ShiftExpression.Instance.AcceptClause(0,_additiveexpression)as ShiftExpression;
            }
            public static ShiftExpression of(ShiftExpression _shiftexpression,ShiftOperator _shiftoperator,AdditiveExpression _additiveexpression)
            {
                return ShiftExpression.Instance.AcceptClause(1,_shiftexpression,_shiftoperator,_additiveexpression)as ShiftExpression;
            }
        }

        public class ShiftOperator:CSharpDefinition
        {
            public static ShiftOperator Instance
            {
                get
                {
                    return new ShiftOperator().DefineAs(
                        N("OpShiftLeft")
                        +
                        N("OpShiftRight")
                    ) as ShiftOperator;
                }
            }
            public static ShiftOperator of(OpShiftLeft _opshiftleft)
            {
                return ShiftOperator.Instance.AcceptClause(0,_opshiftleft)as ShiftOperator;
            }
            public static ShiftOperator of(OpShiftRight _opshiftright)
            {
                return ShiftOperator.Instance.AcceptClause(1,_opshiftright)as ShiftOperator;
            }
        }

        public class RelationalExpression:CSharpDefinition
        {
            public static RelationalExpression Instance
            {
                get
                {
                    return new RelationalExpression().DefineAs(
                        N("ShiftExpression")
                        +
                        N("RelationalExpression") * N("RelationalOperator") * N("ShiftExpression")
                    ) as RelationalExpression;
                }
            }
            public static RelationalExpression of(ShiftExpression _shiftexpression)
            {
                return RelationalExpression.Instance.AcceptClause(0,_shiftexpression)as RelationalExpression;
            }
            public static RelationalExpression of(RelationalExpression _relationalexpression,RelationalOperator _relationaloperator,ShiftExpression _shiftexpression)
            {
                return RelationalExpression.Instance.AcceptClause(1,_relationalexpression,_relationaloperator,_shiftexpression)as RelationalExpression;
            }
        }

        public class RelationalOperator:CSharpDefinition
        {
            public static RelationalOperator Instance
            {
                get
                {
                    return new RelationalOperator().DefineAs(
                        N("OpLt")
                        +
                        N("OpGt")
                        +
                        N("OpLe")
                        +
                        N("OpGe")
                        +
                        N("Is")
                        +
                        N("As")
                    ) as RelationalOperator;
                }
            }
            public static RelationalOperator of(OpLt _oplt)
            {
                return RelationalOperator.Instance.AcceptClause(0,_oplt)as RelationalOperator;
            }
            public static RelationalOperator of(OpGt _opgt)
            {
                return RelationalOperator.Instance.AcceptClause(1,_opgt)as RelationalOperator;
            }
            public static RelationalOperator of(OpLe _ople)
            {
                return RelationalOperator.Instance.AcceptClause(2,_ople)as RelationalOperator;
            }
            public static RelationalOperator of(OpGe _opge)
            {
                return RelationalOperator.Instance.AcceptClause(3,_opge)as RelationalOperator;
            }
            public static RelationalOperator of(Is _is)
            {
                return RelationalOperator.Instance.AcceptClause(4,_is)as RelationalOperator;
            }
            public static RelationalOperator of(As _as)
            {
                return RelationalOperator.Instance.AcceptClause(5,_as)as RelationalOperator;
            }
        }

        public class EqualityExpression:CSharpDefinition
        {
            public static EqualityExpression Instance
            {
                get
                {
                    return new EqualityExpression().DefineAs(
                        N("RelationalExpression")
                        +
                        N("EqualityExpression") * N("EqualityOperator") * N("RelationalExpression")
                    ) as EqualityExpression;
                }
            }
            public static EqualityExpression of(RelationalExpression _relationalexpression)
            {
                return EqualityExpression.Instance.AcceptClause(0,_relationalexpression)as EqualityExpression;
            }
            public static EqualityExpression of(EqualityExpression _equalityexpression,EqualityOperator _equalityoperator,RelationalExpression _relationalexpression)
            {
                return EqualityExpression.Instance.AcceptClause(1,_equalityexpression,_equalityoperator,_relationalexpression)as EqualityExpression;
            }
        }

        public class EqualityOperator:CSharpDefinition
        {
            public static EqualityOperator Instance
            {
                get
                {
                    return new EqualityOperator().DefineAs(
                        N("OpEq")
                        +
                        N("OpNe")
                    ) as EqualityOperator;
                }
            }
            public static EqualityOperator of(OpEq _opeq)
            {
                return EqualityOperator.Instance.AcceptClause(0,_opeq)as EqualityOperator;
            }
            public static EqualityOperator of(OpNe _opne)
            {
                return EqualityOperator.Instance.AcceptClause(1,_opne)as EqualityOperator;
            }
        }

        public class AndExpression:CSharpDefinition
        {
            public static AndExpression Instance
            {
                get
                {
                    return new AndExpression().DefineAs(
                        N("EqualityExpression")
                        +
                        N("AndExpression") * N("BitwiseAnd") * N("EqualityExpression")
                    ) as AndExpression;
                }
            }
            public static AndExpression of(EqualityExpression _equalityexpression)
            {
                return AndExpression.Instance.AcceptClause(0,_equalityexpression)as AndExpression;
            }
            public static AndExpression of(AndExpression _andexpression,EqualityExpression _equalityexpression)
            {
                return AndExpression.Instance.AcceptClause(1,_andexpression,BitwiseAnd.Instance,_equalityexpression)as AndExpression;
            }
        }

        public class ExclusiveOrExpression:CSharpDefinition
        {
            public static ExclusiveOrExpression Instance
            {
                get
                {
                    return new ExclusiveOrExpression().DefineAs(
                        N("AndExpression")
                        +
                        N("ExclusiveOrExpression") * N("Carret") * N("AndExpression")
                    ) as ExclusiveOrExpression;
                }
            }
            public static ExclusiveOrExpression of(AndExpression _andexpression)
            {
                return ExclusiveOrExpression.Instance.AcceptClause(0,_andexpression)as ExclusiveOrExpression;
            }
            public static ExclusiveOrExpression of(ExclusiveOrExpression _exclusiveorexpression,AndExpression _andexpression)
            {
                return ExclusiveOrExpression.Instance.AcceptClause(1,_exclusiveorexpression,Carret.Instance,_andexpression)as ExclusiveOrExpression;
            }
        }

        public class InclusiveOrExpression:CSharpDefinition
        {
            public static InclusiveOrExpression Instance
            {
                get
                {
                    return new InclusiveOrExpression().DefineAs(
                        N("ExclusiveOrExpression")
                        +
                        N("InclusiveOrExpression") * N("BitwiseOr") * N("ExclusiveOrExpression")
                    ) as InclusiveOrExpression;
                }
            }
            public static InclusiveOrExpression of(ExclusiveOrExpression _exclusiveorexpression)
            {
                return InclusiveOrExpression.Instance.AcceptClause(0,_exclusiveorexpression)as InclusiveOrExpression;
            }
            public static InclusiveOrExpression of(InclusiveOrExpression _inclusiveorexpression,ExclusiveOrExpression _exclusiveorexpression)
            {
                return InclusiveOrExpression.Instance.AcceptClause(1,_inclusiveorexpression,BitwiseOr.Instance,_exclusiveorexpression)as InclusiveOrExpression;
            }
        }

        public class ConditionalAndExpression:CSharpDefinition
        {
            public static ConditionalAndExpression Instance
            {
                get
                {
                    return new ConditionalAndExpression().DefineAs(
                        N("InclusiveOrExpression")
                        +
                        N("ConditionalAndExpression") * N("OpAnd") * N("InclusiveOrExpression")
                    ) as ConditionalAndExpression;
                }
            }
            public static ConditionalAndExpression of(InclusiveOrExpression _inclusiveorexpression)
            {
                return ConditionalAndExpression.Instance.AcceptClause(0,_inclusiveorexpression)as ConditionalAndExpression;
            }
            public static ConditionalAndExpression of(ConditionalAndExpression _conditionalandexpression,InclusiveOrExpression _inclusiveorexpression)
            {
                return ConditionalAndExpression.Instance.AcceptClause(1,_conditionalandexpression,OpAnd.Instance,_inclusiveorexpression)as ConditionalAndExpression;
            }
        }

        public class ConditionalOrExpression:CSharpDefinition
        {
            public static ConditionalOrExpression Instance
            {
                get
                {
                    return new ConditionalOrExpression().DefineAs(
                        N("ConditionalAndExpression")
                        +
                        N("ConditionalOrExpression") * N("OpOr") * N("ConditionalAndExpression")
                    ) as ConditionalOrExpression;
                }
            }
            public static ConditionalOrExpression of(ConditionalAndExpression _conditionalandexpression)
            {
                return ConditionalOrExpression.Instance.AcceptClause(0,_conditionalandexpression)as ConditionalOrExpression;
            }
            public static ConditionalOrExpression of(ConditionalOrExpression _conditionalorexpression,ConditionalAndExpression _conditionalandexpression)
            {
                return ConditionalOrExpression.Instance.AcceptClause(1,_conditionalorexpression,OpOr.Instance,_conditionalandexpression)as ConditionalOrExpression;
            }
        }

        public class ConditionalExpression:CSharpDefinition
        {
            public static ConditionalExpression Instance
            {
                get
                {
                    return new ConditionalExpression().DefineAs(
                        N("ConditionalOrExpression")
                        +
                        N("ConditionalOrExpression") * N("Interr") * N("TrueExpression") * N("Colon") * N("FalseExpression")
                    ) as ConditionalExpression;
                }
            }
            public static ConditionalExpression of(ConditionalOrExpression _conditionalorexpression)
            {
                return ConditionalExpression.Instance.AcceptClause(0,_conditionalorexpression)as ConditionalExpression;
            }
            public static ConditionalExpression of(ConditionalOrExpression _conditionalorexpression,TrueExpression _trueexpression,FalseExpression _falseexpression)
            {
                return ConditionalExpression.Instance.AcceptClause(1,_conditionalorexpression,Interr.Instance,_trueexpression,Colon.Instance,_falseexpression)as ConditionalExpression;
            }
        }

        public class TrueExpression:CSharpDefinition
        {
            public static TrueExpression Instance
            {
                get
                {
                    return new TrueExpression().DefineAs(
                        N("Expression")
                    ) as TrueExpression;
                }
            }
            public static TrueExpression of(Expression _expression)
            {
                return TrueExpression.Instance.AcceptClause(0,_expression)as TrueExpression;
            }
        }

        public class FalseExpression:CSharpDefinition
        {
            public static FalseExpression Instance
            {
                get
                {
                    return new FalseExpression().DefineAs(
                        N("Expression")
                    ) as FalseExpression;
                }
            }
            public static FalseExpression of(Expression _expression)
            {
                return FalseExpression.Instance.AcceptClause(0,_expression)as FalseExpression;
            }
        }

        public class AssignmentExpression:CSharpDefinition
        {
            public static AssignmentExpression Instance
            {
                get
                {
                    return new AssignmentExpression().DefineAs(
                        N("PrefixedUnaryExpression") * N("AssignmentOperator") * N("Expression")
                    ) as AssignmentExpression;
                }
            }
            public static AssignmentExpression of(PrefixedUnaryExpression _prefixedunaryexpression,AssignmentOperator _assignmentoperator,Expression _expression)
            {
                return AssignmentExpression.Instance.AcceptClause(0,_prefixedunaryexpression,_assignmentoperator,_expression)as AssignmentExpression;
            }
        }

        public class AssignmentOperator:CSharpDefinition
        {
            public static AssignmentOperator Instance
            {
                get
                {
                    return new AssignmentOperator().DefineAs(
                        N("Assign")
                        +
                        N("OpMultAssign")
                        +
                        N("OpDivAssign")
                        +
                        N("OpModAssign")
                        +
                        N("OpAddAssign")
                        +
                        N("OpSubAssign")
                        +
                        N("OpShiftLeftAssign")
                        +
                        N("OpShiftRightAssign")
                        +
                        N("OpAndAssign")
                        +
                        N("OpOrAssign")
                        +
                        N("OpXorAssign")
                    ) as AssignmentOperator;
                }
            }
            public static AssignmentOperator of(Assign _assign)
            {
                return AssignmentOperator.Instance.AcceptClause(0,_assign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpMultAssign _opmultassign)
            {
                return AssignmentOperator.Instance.AcceptClause(1,_opmultassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpDivAssign _opdivassign)
            {
                return AssignmentOperator.Instance.AcceptClause(2,_opdivassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpModAssign _opmodassign)
            {
                return AssignmentOperator.Instance.AcceptClause(3,_opmodassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpAddAssign _opaddassign)
            {
                return AssignmentOperator.Instance.AcceptClause(4,_opaddassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpSubAssign _opsubassign)
            {
                return AssignmentOperator.Instance.AcceptClause(5,_opsubassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpShiftLeftAssign _opshiftleftassign)
            {
                return AssignmentOperator.Instance.AcceptClause(6,_opshiftleftassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpShiftRightAssign _opshiftrightassign)
            {
                return AssignmentOperator.Instance.AcceptClause(7,_opshiftrightassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpAndAssign _opandassign)
            {
                return AssignmentOperator.Instance.AcceptClause(8,_opandassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpOrAssign _oporassign)
            {
                return AssignmentOperator.Instance.AcceptClause(9,_oporassign)as AssignmentOperator;
            }
            public static AssignmentOperator of(OpXorAssign _opxorassign)
            {
                return AssignmentOperator.Instance.AcceptClause(10,_opxorassign)as AssignmentOperator;
            }
        }

        public class Expression:CSharpDefinition
        {
            public static Expression Instance
            {
                get
                {
                    return new Expression().DefineAs(
                        N("ConditionalExpression")
                        +
                        N("AssignmentExpression")
                    ) as Expression;
                }
            }
            public static Expression of(ConditionalExpression _conditionalexpression)
            {
                return Expression.Instance.AcceptClause(0,_conditionalexpression)as Expression;
            }
            public static Expression of(AssignmentExpression _assignmentexpression)
            {
                return Expression.Instance.AcceptClause(1,_assignmentexpression)as Expression;
            }
        }

        public class ConstantExpression:CSharpDefinition
        {
            public static ConstantExpression Instance
            {
                get
                {
                    return new ConstantExpression().DefineAs(
                        N("Expression")
                    ) as ConstantExpression;
                }
            }
            public static ConstantExpression of(Expression _expression)
            {
                return ConstantExpression.Instance.AcceptClause(0,_expression)as ConstantExpression;
            }
        }

        public class BooleanExpression:CSharpDefinition
        {
            public static BooleanExpression Instance
            {
                get
                {
                    return new BooleanExpression().DefineAs(
                        N("Expression")
                    ) as BooleanExpression;
                }
            }
            public static BooleanExpression of(Expression _expression)
            {
                return BooleanExpression.Instance.AcceptClause(0,_expression)as BooleanExpression;
            }
        }

        public class ClassDeclaration:CSharpDefinition
        {
            public static ClassDeclaration Instance
            {
                get
                {
                    return new ClassDeclaration().DefineAs(
                        ~N("AttributeSection")++ * ~N("Modifier")++ * N("Class") * N("Identifier") * N("ClassBase")++ * N("ClassBody") * N("Semicolon")++
                    ) as ClassDeclaration;
                }
            }
            public static ClassDeclaration of(AttributeSection _attributesection,Modifier _modifier,Identifier _identifier,ClassBase _classbase,ClassBody _classbody)
            {
                return ClassDeclaration.Instance.AcceptClause(0,_attributesection,_modifier,Class.Instance,_identifier,_classbase,_classbody,Semicolon.Instance)as ClassDeclaration;
            }
        }

        public class Modifier:CSharpDefinition
        {
            public static Modifier Instance
            {
                get
                {
                    return new Modifier().DefineAs(
                        N("New")
                        +
                        N("Public")
                        +
                        N("Protected")
                        +
                        N("Internal")
                        +
                        N("Private")
                        +
                        N("Abstract")
                        +
                        N("Sealed")
                        +
                        N("Static")
                        +
                        N("Readonly")
                        +
                        N("Virtual")
                        +
                        N("Override")
                        +
                        N("Extern")
                        +
                        N("Volatile")
                        +
                        N("Unsafe")
                    ) as Modifier;
                }
            }
            public static Modifier of(New _new)
            {
                return Modifier.Instance.AcceptClause(0,_new)as Modifier;
            }
            public static Modifier of(Public _public)
            {
                return Modifier.Instance.AcceptClause(1,_public)as Modifier;
            }
            public static Modifier of(Protected _protected)
            {
                return Modifier.Instance.AcceptClause(2,_protected)as Modifier;
            }
            public static Modifier of(Internal _internal)
            {
                return Modifier.Instance.AcceptClause(3,_internal)as Modifier;
            }
            public static Modifier of(Private _private)
            {
                return Modifier.Instance.AcceptClause(4,_private)as Modifier;
            }
            public static Modifier of(Abstract _abstract)
            {
                return Modifier.Instance.AcceptClause(5,_abstract)as Modifier;
            }
            public static Modifier of(Sealed _sealed)
            {
                return Modifier.Instance.AcceptClause(6,_sealed)as Modifier;
            }
            public static Modifier of(Static _static)
            {
                return Modifier.Instance.AcceptClause(7,_static)as Modifier;
            }
            public static Modifier of(Readonly _readonly)
            {
                return Modifier.Instance.AcceptClause(8,_readonly)as Modifier;
            }
            public static Modifier of(Virtual _virtual)
            {
                return Modifier.Instance.AcceptClause(9,_virtual)as Modifier;
            }
            public static Modifier of(Override _override)
            {
                return Modifier.Instance.AcceptClause(10,_override)as Modifier;
            }
            public static Modifier of(Extern _extern)
            {
                return Modifier.Instance.AcceptClause(11,_extern)as Modifier;
            }
            public static Modifier of(Volatile _volatile)
            {
                return Modifier.Instance.AcceptClause(12,_volatile)as Modifier;
            }
            public static Modifier of(Unsafe _unsafe)
            {
                return Modifier.Instance.AcceptClause(13,_unsafe)as Modifier;
            }
        }

        public class ClassBase:CSharpDefinition
        {
            public static ClassBase Instance
            {
                get
                {
                    return new ClassBase().DefineAs(
                        N("Colon") * N("TypeList")
                    ) as ClassBase;
                }
            }
            public static ClassBase of(TypeList _typelist)
            {
                return ClassBase.Instance.AcceptClause(0,Colon.Instance,_typelist)as ClassBase;
            }
        }

        public class Block:CSharpDefinition
        {
            public static Block Instance
            {
                get
                {
                    return new Block().DefineAs(
                        N("OpenBrace") * ~N("Statement")++ * N("CloseBrace")
                    ) as Block;
                }
            }
            public static Block of(Statement _statement)
            {
                return Block.Instance.AcceptClause(0,OpenBrace.Instance,_statement,CloseBrace.Instance)as Block;
            }
        }

        public class Statement:CSharpDefinition
        {
            public static Statement Instance
            {
                get
                {
                    return new Statement().DefineAs(
                        N("DeclarationStatement")
                        +
                        N("EmbeddedStatement")
                        +
                        N("LabeledStatement")
                    ) as Statement;
                }
            }
            public static Statement of(DeclarationStatement _declarationstatement)
            {
                return Statement.Instance.AcceptClause(0,_declarationstatement)as Statement;
            }
            public static Statement of(EmbeddedStatement _embeddedstatement)
            {
                return Statement.Instance.AcceptClause(1,_embeddedstatement)as Statement;
            }
            public static Statement of(LabeledStatement _labeledstatement)
            {
                return Statement.Instance.AcceptClause(2,_labeledstatement)as Statement;
            }
        }

        public class EmbeddedStatement:CSharpDefinition
        {
            public static EmbeddedStatement Instance
            {
                get
                {
                    return new EmbeddedStatement().DefineAs(
                        N("Block")
                        +
                        N("EmptyStatement")
                        +
                        N("ExpressionStatement")
                        +
                        N("SelectionStatement")
                        +
                        N("IterationStatement")
                        +
                        N("JumpStatement")
                        +
                        N("TryStatement")
                        +
                        N("CheckedStatement")
                        +
                        N("UncheckedStatement")
                        +
                        N("LockStatement")
                        +
                        N("UsingStatement")
                        +
                        N("UnsafeStatement")
                        +
                        N("FixedStatement")
                    ) as EmbeddedStatement;
                }
            }
            public static EmbeddedStatement of(Block _block)
            {
                return EmbeddedStatement.Instance.AcceptClause(0,_block)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(EmptyStatement _emptystatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(1,_emptystatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(ExpressionStatement _expressionstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(2,_expressionstatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(SelectionStatement _selectionstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(3,_selectionstatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(IterationStatement _iterationstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(4,_iterationstatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(JumpStatement _jumpstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(5,_jumpstatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(TryStatement _trystatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(6,_trystatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(CheckedStatement _checkedstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(7,_checkedstatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(UncheckedStatement _uncheckedstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(8,_uncheckedstatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(LockStatement _lockstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(9,_lockstatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(UsingStatement _usingstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(10,_usingstatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(UnsafeStatement _unsafestatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(11,_unsafestatement)as EmbeddedStatement;
            }
            public static EmbeddedStatement of(FixedStatement _fixedstatement)
            {
                return EmbeddedStatement.Instance.AcceptClause(12,_fixedstatement)as EmbeddedStatement;
            }
        }

        public class EmptyStatement:CSharpDefinition
        {
            public static EmptyStatement Instance
            {
                get
                {
                    return new EmptyStatement().DefineAs(
                        N("Semicolon")
                    ) as EmptyStatement;
                }
            }
            public static EmptyStatement of(Semicolon _semicolon)
            {
                return EmptyStatement.Instance.AcceptClause(0,_semicolon)as EmptyStatement;
            }
        }

        public class LabeledStatement:CSharpDefinition
        {
            public static LabeledStatement Instance
            {
                get
                {
                    return new LabeledStatement().DefineAs(
                        N("Identifier") * N("Colon") * N("Statement")
                    ) as LabeledStatement;
                }
            }
            public static LabeledStatement of(Identifier _identifier,Statement _statement)
            {
                return LabeledStatement.Instance.AcceptClause(0,_identifier,Colon.Instance,_statement)as LabeledStatement;
            }
        }

        public class DeclarationStatement:CSharpDefinition
        {
            public static DeclarationStatement Instance
            {
                get
                {
                    return new DeclarationStatement().DefineAs(
                        N("LocalVariableDeclaration") * N("Semicolon")
                        +
                        N("LocalConstantDeclaration") * N("Semicolon")
                    ) as DeclarationStatement;
                }
            }
            public static DeclarationStatement of(LocalVariableDeclaration _localvariabledeclaration)
            {
                return DeclarationStatement.Instance.AcceptClause(0,_localvariabledeclaration,Semicolon.Instance)as DeclarationStatement;
            }
            public static DeclarationStatement of(LocalConstantDeclaration _localconstantdeclaration)
            {
                return DeclarationStatement.Instance.AcceptClause(1,_localconstantdeclaration,Semicolon.Instance)as DeclarationStatement;
            }
        }

        public class LocalVariableType:CSharpDefinition
        {
            public static LocalVariableType Instance
            {
                get
                {
                    return new LocalVariableType().DefineAs(
                        N("PrimaryExpression") * N("RankSpecifier")++
                        +
                        N("BuiltinTypes") * N("RankSpecifier")++
                    ) as LocalVariableType;
                }
            }
            public static LocalVariableType of(PrimaryExpression _primaryexpression,RankSpecifier _rankspecifier)
            {
                return LocalVariableType.Instance.AcceptClause(0,_primaryexpression,_rankspecifier)as LocalVariableType;
            }
            public static LocalVariableType of(BuiltinTypes _builtintypes,RankSpecifier _rankspecifier)
            {
                return LocalVariableType.Instance.AcceptClause(1,_builtintypes,_rankspecifier)as LocalVariableType;
            }
        }

        public class LocalVariablePointerType:CSharpDefinition
        {
            public static LocalVariablePointerType Instance
            {
                get
                {
                    return new LocalVariablePointerType().DefineAs(
                        N("PrimaryExpression") * N("Star")
                        +
                        N("BuiltinTypes") * N("Star")
                        +
                        N("Void") * N("Star")
                        +
                        N("LocalVariablePointerType") * N("Star")
                    ) as LocalVariablePointerType;
                }
            }
            public static LocalVariablePointerType of(PrimaryExpression _primaryexpression)
            {
                return LocalVariablePointerType.Instance.AcceptClause(0,_primaryexpression,Star.Instance)as LocalVariablePointerType;
            }
            public static LocalVariablePointerType of(BuiltinTypes _builtintypes)
            {
                return LocalVariablePointerType.Instance.AcceptClause(1,_builtintypes,Star.Instance)as LocalVariablePointerType;
            }
            public static LocalVariablePointerType of(LocalVariablePointerType _localvariablepointertype)
            {
                return LocalVariablePointerType.Instance.AcceptClause(3,_localvariablepointertype,Star.Instance)as LocalVariablePointerType;
            }
        }

        public class LocalVariableDeclaration:CSharpDefinition
        {
            public static LocalVariableDeclaration Instance
            {
                get
                {
                    return new LocalVariableDeclaration().DefineAs(
                        N("LocalVariableType") * N("VariableDeclarators")
                        +
                        N("LocalVariablePointerType") * N("RankSpecifier")++ * N("VariableDeclarators")
                    ) as LocalVariableDeclaration;
                }
            }
            public static LocalVariableDeclaration of(LocalVariableType _localvariabletype,VariableDeclarators _variabledeclarators)
            {
                return LocalVariableDeclaration.Instance.AcceptClause(0,_localvariabletype,_variabledeclarators)as LocalVariableDeclaration;
            }
            public static LocalVariableDeclaration of(LocalVariablePointerType _localvariablepointertype,RankSpecifier _rankspecifier,VariableDeclarators _variabledeclarators)
            {
                return LocalVariableDeclaration.Instance.AcceptClause(1,_localvariablepointertype,_rankspecifier,_variabledeclarators)as LocalVariableDeclaration;
            }
        }

        public class LocalConstantDeclaration:CSharpDefinition
        {
            public static LocalConstantDeclaration Instance
            {
                get
                {
                    return new LocalConstantDeclaration().DefineAs(
                        N("Const") * N("LocalVariableType") * N("ConstantDeclarator")
                    ) as LocalConstantDeclaration;
                }
            }
            public static LocalConstantDeclaration of(LocalVariableType _localvariabletype,ConstantDeclarator _constantdeclarator)
            {
                return LocalConstantDeclaration.Instance.AcceptClause(0,Const.Instance,_localvariabletype,_constantdeclarator)as LocalConstantDeclaration;
            }
        }

        public class ExpressionStatement:CSharpDefinition
        {
            public static ExpressionStatement Instance
            {
                get
                {
                    return new ExpressionStatement().DefineAs(
                        N("StatementExpression") * N("Semicolon")
                    ) as ExpressionStatement;
                }
            }
            public static ExpressionStatement of(StatementExpression _statementexpression)
            {
                return ExpressionStatement.Instance.AcceptClause(0,_statementexpression,Semicolon.Instance)as ExpressionStatement;
            }
        }

        public class StatementExpression:CSharpDefinition
        {
            public static StatementExpression Instance
            {
                get
                {
                    return new StatementExpression().DefineAs(
                        N("InvocationExpression")
                        +
                        N("ObjectCreationExpression")
                        +
                        N("AssignmentExpression")
                        +
                        N("PostIncrementExpression")
                        +
                        N("PostDecrementExpression")
                        +
                        N("PreIncrementExpression")
                        +
                        N("PreDecrementExpression")
                        +
                        N("Error")
                    ) as StatementExpression;
                }
            }
            public static StatementExpression of(InvocationExpression _invocationexpression)
            {
                return StatementExpression.Instance.AcceptClause(0,_invocationexpression)as StatementExpression;
            }
            public static StatementExpression of(ObjectCreationExpression _objectcreationexpression)
            {
                return StatementExpression.Instance.AcceptClause(1,_objectcreationexpression)as StatementExpression;
            }
            public static StatementExpression of(AssignmentExpression _assignmentexpression)
            {
                return StatementExpression.Instance.AcceptClause(2,_assignmentexpression)as StatementExpression;
            }
            public static StatementExpression of(PostIncrementExpression _postincrementexpression)
            {
                return StatementExpression.Instance.AcceptClause(3,_postincrementexpression)as StatementExpression;
            }
            public static StatementExpression of(PostDecrementExpression _postdecrementexpression)
            {
                return StatementExpression.Instance.AcceptClause(4,_postdecrementexpression)as StatementExpression;
            }
            public static StatementExpression of(PreIncrementExpression _preincrementexpression)
            {
                return StatementExpression.Instance.AcceptClause(5,_preincrementexpression)as StatementExpression;
            }
            public static StatementExpression of(PreDecrementExpression _predecrementexpression)
            {
                return StatementExpression.Instance.AcceptClause(6,_predecrementexpression)as StatementExpression;
            }
            public static StatementExpression of(Error _error)
            {
                return StatementExpression.Instance.AcceptClause(7,_error)as StatementExpression;
            }
        }

        public class ObjectCreationExpression:CSharpDefinition
        {
            public static ObjectCreationExpression Instance
            {
                get
                {
                    return new ObjectCreationExpression().DefineAs(
                        N("ObjectOrDelegateCreationExpression")
                    ) as ObjectCreationExpression;
                }
            }
            public static ObjectCreationExpression of(ObjectOrDelegateCreationExpression _objectordelegatecreationexpression)
            {
                return ObjectCreationExpression.Instance.AcceptClause(0,_objectordelegatecreationexpression)as ObjectCreationExpression;
            }
        }

        public class SelectionStatement:CSharpDefinition
        {
            public static SelectionStatement Instance
            {
                get
                {
                    return new SelectionStatement().DefineAs(
                        N("IfStatement")
                        +
                        N("SwitchStatement")
                    ) as SelectionStatement;
                }
            }
            public static SelectionStatement of(IfStatement _ifstatement)
            {
                return SelectionStatement.Instance.AcceptClause(0,_ifstatement)as SelectionStatement;
            }
            public static SelectionStatement of(SwitchStatement _switchstatement)
            {
                return SelectionStatement.Instance.AcceptClause(1,_switchstatement)as SelectionStatement;
            }
        }

        public class IfStatement:CSharpDefinition
        {
            public static IfStatement Instance
            {
                get
                {
                    return new IfStatement().DefineAs(
                        N("If") * N("OpenParens") * N("BooleanExpression") * N("CloseParens") * N("TrueStatement")
                        +
                        N("If") * N("OpenParens") * N("BooleanExpression") * N("CloseParens") * N("TrueStatement") * N("Else") * N("FalseStatement")
                    ) as IfStatement;
                }
            }
            public static IfStatement of(BooleanExpression _booleanexpression,TrueStatement _truestatement)
            {
                return IfStatement.Instance.AcceptClause(0,If.Instance,OpenParens.Instance,_booleanexpression,CloseParens.Instance,_truestatement)as IfStatement;
            }
            public static IfStatement of(BooleanExpression _booleanexpression,TrueStatement _truestatement,FalseStatement _falsestatement)
            {
                return IfStatement.Instance.AcceptClause(1,If.Instance,OpenParens.Instance,_booleanexpression,CloseParens.Instance,_truestatement,Else.Instance,_falsestatement)as IfStatement;
            }
        }

        public class TrueStatement:CSharpDefinition
        {
            public static TrueStatement Instance
            {
                get
                {
                    return new TrueStatement().DefineAs(
                        N("EmbeddedStatement")
                    ) as TrueStatement;
                }
            }
            public static TrueStatement of(EmbeddedStatement _embeddedstatement)
            {
                return TrueStatement.Instance.AcceptClause(0,_embeddedstatement)as TrueStatement;
            }
        }

        public class FalseStatement:CSharpDefinition
        {
            public static FalseStatement Instance
            {
                get
                {
                    return new FalseStatement().DefineAs(
                        N("EmbeddedStatement")
                    ) as FalseStatement;
                }
            }
            public static FalseStatement of(EmbeddedStatement _embeddedstatement)
            {
                return FalseStatement.Instance.AcceptClause(0,_embeddedstatement)as FalseStatement;
            }
        }

        public class SwitchStatement:CSharpDefinition
        {
            public static SwitchStatement Instance
            {
                get
                {
                    return new SwitchStatement().DefineAs(
                        N("Switch") * N("OpenParens") * N("Expression") * N("CloseParens") * N("SwitchBlock")
                    ) as SwitchStatement;
                }
            }
            public static SwitchStatement of(Expression _expression,SwitchBlock _switchblock)
            {
                return SwitchStatement.Instance.AcceptClause(0,Switch.Instance,OpenParens.Instance,_expression,CloseParens.Instance,_switchblock)as SwitchStatement;
            }
        }

        public class SwitchBlock:CSharpDefinition
        {
            public static SwitchBlock Instance
            {
                get
                {
                    return new SwitchBlock().DefineAs(
                        N("OpenBrace") * ~N("SwitchSection")++ * N("CloseBrace")
                    ) as SwitchBlock;
                }
            }
            public static SwitchBlock of(SwitchSection _switchsection)
            {
                return SwitchBlock.Instance.AcceptClause(0,OpenBrace.Instance,_switchsection,CloseBrace.Instance)as SwitchBlock;
            }
        }

        public class SwitchSection:CSharpDefinition
        {
            public static SwitchSection Instance
            {
                get
                {
                    return new SwitchSection().DefineAs(
                        ~N("SwitchLabel") * ~N("Statement")
                    ) as SwitchSection;
                }
            }
            public static SwitchSection of(SwitchLabel _switchlabel,Statement _statement)
            {
                return SwitchSection.Instance.AcceptClause(0,_switchlabel,_statement)as SwitchSection;
            }
        }

        public class SwitchLabel:CSharpDefinition
        {
            public static SwitchLabel Instance
            {
                get
                {
                    return new SwitchLabel().DefineAs(
                        N("Case") * N("ConstantExpression") * N("Colon")
                        +
                        N("Default") * N("Colon")
                        +
                        N("Error")
                    ) as SwitchLabel;
                }
            }
            public static SwitchLabel of(ConstantExpression _constantexpression)
            {
                return SwitchLabel.Instance.AcceptClause(0,Case.Instance,_constantexpression,Colon.Instance)as SwitchLabel;
            }
            public static SwitchLabel of(Error _error)
            {
                return SwitchLabel.Instance.AcceptClause(2,_error)as SwitchLabel;
            }
        }

        public class IterationStatement:CSharpDefinition
        {
            public static IterationStatement Instance
            {
                get
                {
                    return new IterationStatement().DefineAs(
                        N("WhileStatement")
                        +
                        N("DoStatement")
                        +
                        N("ForStatement")
                        +
                        N("ForeachStatement")
                    ) as IterationStatement;
                }
            }
            public static IterationStatement of(WhileStatement _whilestatement)
            {
                return IterationStatement.Instance.AcceptClause(0,_whilestatement)as IterationStatement;
            }
            public static IterationStatement of(DoStatement _dostatement)
            {
                return IterationStatement.Instance.AcceptClause(1,_dostatement)as IterationStatement;
            }
            public static IterationStatement of(ForStatement _forstatement)
            {
                return IterationStatement.Instance.AcceptClause(2,_forstatement)as IterationStatement;
            }
            public static IterationStatement of(ForeachStatement _foreachstatement)
            {
                return IterationStatement.Instance.AcceptClause(3,_foreachstatement)as IterationStatement;
            }
        }

        public class WhileStatement:CSharpDefinition
        {
            public static WhileStatement Instance
            {
                get
                {
                    return new WhileStatement().DefineAs(
                        N("While") * N("OpenParens") * N("BooleanExpression") * N("CloseParens") * N("EmbeddedStatement")
                    ) as WhileStatement;
                }
            }
            public static WhileStatement of(BooleanExpression _booleanexpression,EmbeddedStatement _embeddedstatement)
            {
                return WhileStatement.Instance.AcceptClause(0,While.Instance,OpenParens.Instance,_booleanexpression,CloseParens.Instance,_embeddedstatement)as WhileStatement;
            }
        }

        public class DoStatement:CSharpDefinition
        {
            public static DoStatement Instance
            {
                get
                {
                    return new DoStatement().DefineAs(
                        N("Do") * N("EmbeddedStatement") * N("While") * N("OpenParens") * N("BooleanExpression") * N("CloseParens") * N("Semicolon")
                    ) as DoStatement;
                }
            }
            public static DoStatement of(EmbeddedStatement _embeddedstatement,BooleanExpression _booleanexpression)
            {
                return DoStatement.Instance.AcceptClause(0,Do.Instance,_embeddedstatement,While.Instance,OpenParens.Instance,_booleanexpression,CloseParens.Instance,Semicolon.Instance)as DoStatement;
            }
        }

        public class ForStatement:CSharpDefinition
        {
            public static ForStatement Instance
            {
                get
                {
                    return new ForStatement().DefineAs(
                        N("For") * N("OpenParens") * N("ForInitializer")++ * N("Semicolon") * N("ForCondition")++ * N("Semicolon") * N("ForIterator")++ * N("CloseParens") * N("EmbeddedStatement")
                    ) as ForStatement;
                }
            }
            public static ForStatement of(ForInitializer _forinitializer,ForCondition _forcondition,ForIterator _foriterator,EmbeddedStatement _embeddedstatement)
            {
                return ForStatement.Instance.AcceptClause(0,For.Instance,OpenParens.Instance,_forinitializer,Semicolon.Instance,_forcondition,Semicolon.Instance,_foriterator,CloseParens.Instance,_embeddedstatement)as ForStatement;
            }
        }

        public class ForInitializer:CSharpDefinition
        {
            public static ForInitializer Instance
            {
                get
                {
                    return new ForInitializer().DefineAs(
                        N("LocalVariableDeclaration")
                        +
                        N("StatementExpressionList")
                    ) as ForInitializer;
                }
            }
            public static ForInitializer of(LocalVariableDeclaration _localvariabledeclaration)
            {
                return ForInitializer.Instance.AcceptClause(0,_localvariabledeclaration)as ForInitializer;
            }
            public static ForInitializer of(StatementExpressionList _statementexpressionlist)
            {
                return ForInitializer.Instance.AcceptClause(1,_statementexpressionlist)as ForInitializer;
            }
        }

        public class ForCondition:CSharpDefinition
        {
            public static ForCondition Instance
            {
                get
                {
                    return new ForCondition().DefineAs(
                        N("BooleanExpression")
                    ) as ForCondition;
                }
            }
            public static ForCondition of(BooleanExpression _booleanexpression)
            {
                return ForCondition.Instance.AcceptClause(0,_booleanexpression)as ForCondition;
            }
        }

        public class ForIterator:CSharpDefinition
        {
            public static ForIterator Instance
            {
                get
                {
                    return new ForIterator().DefineAs(
                        N("StatementExpressionList")
                    ) as ForIterator;
                }
            }
            public static ForIterator of(StatementExpressionList _statementexpressionlist)
            {
                return ForIterator.Instance.AcceptClause(0,_statementexpressionlist)as ForIterator;
            }
        }

        public class StatementExpressionList:CSharpDefinition
        {
            public static StatementExpressionList Instance
            {
                get
                {
                    return new StatementExpressionList().DefineAs(
                        N("StatementExpression")
                        +
                        N("StatementExpressionList") * N("Comma") * N("StatementExpression")
                    ) as StatementExpressionList;
                }
            }
            public static StatementExpressionList of(StatementExpression _statementexpression)
            {
                return StatementExpressionList.Instance.AcceptClause(0,_statementexpression)as StatementExpressionList;
            }
            public static StatementExpressionList of(StatementExpressionList _statementexpressionlist,StatementExpression _statementexpression)
            {
                return StatementExpressionList.Instance.AcceptClause(1,_statementexpressionlist,Comma.Instance,_statementexpression)as StatementExpressionList;
            }
        }

        public class ForeachStatement:CSharpDefinition
        {
            public static ForeachStatement Instance
            {
                get
                {
                    return new ForeachStatement().DefineAs(
                        N("Foreach") * N("OpenParens") * N("Type") * N("Identifier") * N("In") * N("Expression") * N("CloseParens") * N("EmbeddedStatement")
                    ) as ForeachStatement;
                }
            }
            public static ForeachStatement of(Type _type,Identifier _identifier,Expression _expression,EmbeddedStatement _embeddedstatement)
            {
                return ForeachStatement.Instance.AcceptClause(0,Foreach.Instance,OpenParens.Instance,_type,_identifier,In.Instance,_expression,CloseParens.Instance,_embeddedstatement)as ForeachStatement;
            }
        }

        public class JumpStatement:CSharpDefinition
        {
            public static JumpStatement Instance
            {
                get
                {
                    return new JumpStatement().DefineAs(
                        N("BreakStatement")
                        +
                        N("ContinueStatement")
                        +
                        N("GotoStatement")
                        +
                        N("ReturnStatement")
                        +
                        N("ThrowStatement")
                    ) as JumpStatement;
                }
            }
            public static JumpStatement of(BreakStatement _breakstatement)
            {
                return JumpStatement.Instance.AcceptClause(0,_breakstatement)as JumpStatement;
            }
            public static JumpStatement of(ContinueStatement _continuestatement)
            {
                return JumpStatement.Instance.AcceptClause(1,_continuestatement)as JumpStatement;
            }
            public static JumpStatement of(GotoStatement _gotostatement)
            {
                return JumpStatement.Instance.AcceptClause(2,_gotostatement)as JumpStatement;
            }
            public static JumpStatement of(ReturnStatement _returnstatement)
            {
                return JumpStatement.Instance.AcceptClause(3,_returnstatement)as JumpStatement;
            }
            public static JumpStatement of(ThrowStatement _throwstatement)
            {
                return JumpStatement.Instance.AcceptClause(4,_throwstatement)as JumpStatement;
            }
        }

        public class BreakStatement:CSharpDefinition
        {
            public static BreakStatement Instance
            {
                get
                {
                    return new BreakStatement().DefineAs(
                        N("Break") * N("Semicolon")
                    ) as BreakStatement;
                }
            }
        }

        public class ContinueStatement:CSharpDefinition
        {
            public static ContinueStatement Instance
            {
                get
                {
                    return new ContinueStatement().DefineAs(
                        N("Continue") * N("Semicolon")
                    ) as ContinueStatement;
                }
            }
        }

        public class GotoStatement:CSharpDefinition
        {
            public static GotoStatement Instance
            {
                get
                {
                    return new GotoStatement().DefineAs(
                        N("Goto") * N("Identifier") * N("Semicolon")
                        +
                        N("Goto") * N("Case") * N("ConstantExpression") * N("Semicolon")
                        +
                        N("Goto") * N("Default") * N("Semicolon")
                    ) as GotoStatement;
                }
            }
            public static GotoStatement of(Identifier _identifier)
            {
                return GotoStatement.Instance.AcceptClause(0,Goto.Instance,_identifier,Semicolon.Instance)as GotoStatement;
            }
            public static GotoStatement of(ConstantExpression _constantexpression)
            {
                return GotoStatement.Instance.AcceptClause(1,Goto.Instance,Case.Instance,_constantexpression,Semicolon.Instance)as GotoStatement;
            }
        }

        public class ReturnStatement:CSharpDefinition
        {
            public static ReturnStatement Instance
            {
                get
                {
                    return new ReturnStatement().DefineAs(
                        N("Return") * N("Expression")++ * N("Semicolon")
                    ) as ReturnStatement;
                }
            }
            public static ReturnStatement of(Expression _expression)
            {
                return ReturnStatement.Instance.AcceptClause(0,Return.Instance,_expression,Semicolon.Instance)as ReturnStatement;
            }
        }

        public class ThrowStatement:CSharpDefinition
        {
            public static ThrowStatement Instance
            {
                get
                {
                    return new ThrowStatement().DefineAs(
                        N("Throw") * N("Expression")++ * N("Semicolon")
                    ) as ThrowStatement;
                }
            }
            public static ThrowStatement of(Expression _expression)
            {
                return ThrowStatement.Instance.AcceptClause(0,Throw.Instance,_expression,Semicolon.Instance)as ThrowStatement;
            }
        }

        public class TryStatement:CSharpDefinition
        {
            public static TryStatement Instance
            {
                get
                {
                    return new TryStatement().DefineAs(
                        N("Try") * N("TryBlock") * ~N("CatchClause")
                        +
                        N("Try") * N("TryBlock") * ~N("CatchClause")++ * N("Finally") * N("FinallyBlock")
                        +
                        N("Try") * N("TryBlock") * N("Error")
                    ) as TryStatement;
                }
            }
            public static TryStatement of(TryBlock _tryblock,CatchClause _catchclause)
            {
                return TryStatement.Instance.AcceptClause(0,Try.Instance,_tryblock,_catchclause)as TryStatement;
            }
            public static TryStatement of(TryBlock _tryblock,CatchClause _catchclause,FinallyBlock _finallyblock)
            {
                return TryStatement.Instance.AcceptClause(1,Try.Instance,_tryblock,_catchclause,Finally.Instance,_finallyblock)as TryStatement;
            }
            public static TryStatement of(TryBlock _tryblock,Error _error)
            {
                return TryStatement.Instance.AcceptClause(2,Try.Instance,_tryblock,_error)as TryStatement;
            }
        }

        public class TryBlock:CSharpDefinition
        {
            public static TryBlock Instance
            {
                get
                {
                    return new TryBlock().DefineAs(
                        N("Block")
                    ) as TryBlock;
                }
            }
            public static TryBlock of(Block _block)
            {
                return TryBlock.Instance.AcceptClause(0,_block)as TryBlock;
            }
        }

        public class FinallyBlock:CSharpDefinition
        {
            public static FinallyBlock Instance
            {
                get
                {
                    return new FinallyBlock().DefineAs(
                        N("Block")
                    ) as FinallyBlock;
                }
            }
            public static FinallyBlock of(Block _block)
            {
                return FinallyBlock.Instance.AcceptClause(0,_block)as FinallyBlock;
            }
        }

        public class CatchClause:CSharpDefinition
        {
            public static CatchClause Instance
            {
                get
                {
                    return new CatchClause().DefineAs(
                        N("Catch") * N("CatchArgs")++ * N("Block")
                    ) as CatchClause;
                }
            }
            public static CatchClause of(CatchArgs _catchargs,Block _block)
            {
                return CatchClause.Instance.AcceptClause(0,Catch.Instance,_catchargs,_block)as CatchClause;
            }
        }

        public class CatchArgs:CSharpDefinition
        {
            public static CatchArgs Instance
            {
                get
                {
                    return new CatchArgs().DefineAs(
                        N("OpenParens") * N("Type") * N("Identifier")++ * N("CloseParens")
                    ) as CatchArgs;
                }
            }
            public static CatchArgs of(Type _type,Identifier _identifier)
            {
                return CatchArgs.Instance.AcceptClause(0,OpenParens.Instance,_type,_identifier,CloseParens.Instance)as CatchArgs;
            }
        }

        public class CheckedStatement:CSharpDefinition
        {
            public static CheckedStatement Instance
            {
                get
                {
                    return new CheckedStatement().DefineAs(
                        N("Checked") * N("Block")
                    ) as CheckedStatement;
                }
            }
            public static CheckedStatement of(Block _block)
            {
                return CheckedStatement.Instance.AcceptClause(0,Checked.Instance,_block)as CheckedStatement;
            }
        }

        public class UncheckedStatement:CSharpDefinition
        {
            public static UncheckedStatement Instance
            {
                get
                {
                    return new UncheckedStatement().DefineAs(
                        N("Unchecked") * N("Block")
                    ) as UncheckedStatement;
                }
            }
            public static UncheckedStatement of(Block _block)
            {
                return UncheckedStatement.Instance.AcceptClause(0,Unchecked.Instance,_block)as UncheckedStatement;
            }
        }

        public class UnsafeStatement:CSharpDefinition
        {
            public static UnsafeStatement Instance
            {
                get
                {
                    return new UnsafeStatement().DefineAs(
                        N("Unsafe") * N("Block")
                    ) as UnsafeStatement;
                }
            }
            public static UnsafeStatement of(Block _block)
            {
                return UnsafeStatement.Instance.AcceptClause(0,Unsafe.Instance,_block)as UnsafeStatement;
            }
        }

        public class FixedStatement:CSharpDefinition
        {
            public static FixedStatement Instance
            {
                get
                {
                    return new FixedStatement().DefineAs(
                        N("Fixed") * N("OpenParens") * N("PointerType") * N("FixedPointerDeclarators") * N("CloseParens") * N("EmbeddedStatement")
                    ) as FixedStatement;
                }
            }
            public static FixedStatement of(PointerType _pointertype,FixedPointerDeclarators _fixedpointerdeclarators,EmbeddedStatement _embeddedstatement)
            {
                return FixedStatement.Instance.AcceptClause(0,Fixed.Instance,OpenParens.Instance,_pointertype,_fixedpointerdeclarators,CloseParens.Instance,_embeddedstatement)as FixedStatement;
            }
        }

        public class FixedPointerDeclarators:CSharpDefinition
        {
            public static FixedPointerDeclarators Instance
            {
                get
                {
                    return new FixedPointerDeclarators().DefineAs(
                        N("FixedPointerDeclarator")
                        +
                        N("FixedPointerDeclarators") * N("Comma") * N("FixedPointerDeclarator")
                    ) as FixedPointerDeclarators;
                }
            }
            public static FixedPointerDeclarators of(FixedPointerDeclarator _fixedpointerdeclarator)
            {
                return FixedPointerDeclarators.Instance.AcceptClause(0,_fixedpointerdeclarator)as FixedPointerDeclarators;
            }
            public static FixedPointerDeclarators of(FixedPointerDeclarators _fixedpointerdeclarators,FixedPointerDeclarator _fixedpointerdeclarator)
            {
                return FixedPointerDeclarators.Instance.AcceptClause(1,_fixedpointerdeclarators,Comma.Instance,_fixedpointerdeclarator)as FixedPointerDeclarators;
            }
        }

        public class FixedPointerDeclarator:CSharpDefinition
        {
            public static FixedPointerDeclarator Instance
            {
                get
                {
                    return new FixedPointerDeclarator().DefineAs(
                        N("Identifier") * N("Assign") * N("Expression")
                    ) as FixedPointerDeclarator;
                }
            }
            public static FixedPointerDeclarator of(Identifier _identifier,Expression _expression)
            {
                return FixedPointerDeclarator.Instance.AcceptClause(0,_identifier,Assign.Instance,_expression)as FixedPointerDeclarator;
            }
        }

        public class LockStatement:CSharpDefinition
        {
            public static LockStatement Instance
            {
                get
                {
                    return new LockStatement().DefineAs(
                        N("Lock") * N("OpenParens") * N("Expression") * N("CloseParens") * N("EmbeddedStatement")
                    ) as LockStatement;
                }
            }
            public static LockStatement of(Expression _expression,EmbeddedStatement _embeddedstatement)
            {
                return LockStatement.Instance.AcceptClause(0,Lock.Instance,OpenParens.Instance,_expression,CloseParens.Instance,_embeddedstatement)as LockStatement;
            }
        }

        public class UsingStatement:CSharpDefinition
        {
            public static UsingStatement Instance
            {
                get
                {
                    return new UsingStatement().DefineAs(
                        N("Using") * N("OpenParens") * N("ResourceAcquisition") * N("CloseParens") * N("EmbeddedStatement")
                    ) as UsingStatement;
                }
            }
            public static UsingStatement of(ResourceAcquisition _resourceacquisition,EmbeddedStatement _embeddedstatement)
            {
                return UsingStatement.Instance.AcceptClause(0,Using.Instance,OpenParens.Instance,_resourceacquisition,CloseParens.Instance,_embeddedstatement)as UsingStatement;
            }
        }

        public class ResourceAcquisition:CSharpDefinition
        {
            public static ResourceAcquisition Instance
            {
                get
                {
                    return new ResourceAcquisition().DefineAs(
                        N("LocalVariableDeclaration")
                        +
                        N("Expression")
                    ) as ResourceAcquisition;
                }
            }
            public static ResourceAcquisition of(LocalVariableDeclaration _localvariabledeclaration)
            {
                return ResourceAcquisition.Instance.AcceptClause(0,_localvariabledeclaration)as ResourceAcquisition;
            }
            public static ResourceAcquisition of(Expression _expression)
            {
                return ResourceAcquisition.Instance.AcceptClause(1,_expression)as ResourceAcquisition;
            }
        }

    }
}
